{"bugs":{"url":"https://github.com/drizzle-team/drizzle-orm/issues"},"dist":{"shasum":"efb1aa48a4fab88d3c84fe18ad8c5a332c1f33a5","tarball":"https://registry.npmjs.org/drizzle-orm-sqlite/-/drizzle-orm-sqlite-0.15.2.tgz","fileCount":159,"integrity":"sha512-Qq9M41SXc7M8L0LISzzcX/exCgKByMbh7F0uplAEjdn6zn0HnvmmRnN36FWktmnds2dmyeowJSYXwUaynigCRw==","signatures":[{"sig":"MEUCIGd0kmsyzIX5VtlDz4eK/dmbwGaLSgvtsy0pBvVi3XHTAiEAiiUH+Iou7cKe81mSKSW2RkW1Toil1nkvalsML91ZUMM=","keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA"}],"unpackedSize":244658,"npm-signature":"-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v4.10.10\r\nComment: https://openpgpjs.org\r\n\r\nwsFzBAEBCAAGBQJjxVouACEJED1NWxICdlZqFiEECWMYAoorWMhJKdjhPU1b\r\nEgJ2VmpJ1Q//fXncmiYXCcGvPzv2h1V2hFCPCjaWA+PW2zV5L+9zBxPdCNx7\r\nho0SMJoP6OK+Yn9/EXQLuk4mLn56V1QOJH2nTamaFCKL7RDWsojSqq5foe1M\r\njCK6JcDdtJqfB2F0uI2fs1ACpc5/mDy6P26v2caststdpKFsgyDOGW6UVF85\r\nzbztEKeVf+BLR6rbyvWhXmp3iL0t5PJU7urEOUj/5qzYQCsjRrd/6WR/LMS+\r\ndAa53DwKyo0S2lHZ3QjcX12jrKWD1fn9cTZtvoiH8dlzPcl6Ad6XYE39FSB6\r\n4Jp4w8T6CV43WBhR1vY7/+qqRrUbmRSLXFd49WNJNpRKw0AXNfbxyUBWfRnb\r\nd3LYCPGFVJ6oVzA1sZZ5MD8HzD1E1ggq1PCM/78BVgaBL6XxPmNOMl3JIV24\r\nBJYGXtv0XdVPu/RNrly0d+IwqTLU6JoENzO+uDXDZ/9mXYK4qcsPHQXu3+JH\r\nMJ2JXGV/PaDuRrMNoO6hPYVQtFvbtrCkPXl5YPTXWWeC0BZJWcimkNk/P3Gd\r\nBe7by8Mp7guOPToZWmtaskIag4O2t1J/Jh0ZDPH3Pcu/Znojv1PfOJ+vzsf+\r\nboW/2DBy55sg/7hH47jHXq5dcCDclCCGzdNyJbTTqNUDAM0Cia7Q4xf/IRuR\r\nvcVqmWb1CBzhkoWCKFdsnXGl3Hg8X6Jxiuw=\r\n=Jpkg\r\n-----END PGP SIGNATURE-----\r\n"},"name":"drizzle-orm-sqlite","_from":"file:package.tgz","types":"./index.d.ts","author":{"name":"Drizzle Team"},"readme":"# Drizzle ORM | SQLite\nDrizzleORM is a [tiny](https://twitter.com/_alexblokh/status/1594735880417472512), [blazingly fast](#performance-and-prepared-statements) TypeScript ORM library with a [drizzle-kit](#migrations) CLI companion for automatic SQL migrations generation. \nHere you can find extensive docs for SQLite module.\n\n| Driver         | Support |            |\n|:--             |  :---:  | :--        |\n| better-sqlite3 | ✅      |            |\n| node-sqlite    | ⏳      |            |            \n| bun:sqlite     | ✅      |[example project](https://github.com/drizzle-team/drizzle-orm/tree/main/examples/bun-sqlite)|  \n| Cloudflare D1  | ✅      |[example project](https://github.com/drizzle-team/drizzle-orm/tree/main/examples/cloudflare-d1)|\n| Fly.io LiteFS  | ✅      |            |\n\n## 💾 Installation\n```bash\nnpm install drizzle-orm drizzle-orm-sqlite better-sqlite3\n## opt-in automatic migrations generator\nnpm install -D drizzle-kit \n```\n\n## 🚀 Quick start\n```typescript\nimport { sqliteTable, text, integer } from \"drizzle-orm-sqlite\";\nimport { drizzle } from 'drizzle-orm-sqlite/better-sqlite3';\nimport Database from \"better-sqlite3\";\n\nconst users = sqliteTable(\"users\", {\n  id: integer(\"id\").primaryKey(),\n  fullName: text('full_name'),\n})\n\nconst sqlite = new Database(\"sqlite.db\");\nconst db = drizzle(sqlite);\n\nconst users = db.select(users).all();\n```\n\n## Connecting to databases\n```typescript\n// better-sqlite3 or fly.io LiteFS\nimport { drizzle, BetterSQLite3Database } from 'drizzle-orm-sqlite/better-sqlite3';\nimport Database from \"better-sqlite3\";\n\nconst sqlite = new Database(\"sqlite.db\");\nconst db: BetterSQLite3Database = drizzle(sqlite);\nconst result = db.select(users).all()\n\n// bun js embedded sqlite connector\nimport { drizzle, BunSQLiteDatabase } from \"drizzle-orm-sqlite/bun\";\nimport { Database } from \"bun:sqlite\";\n\nconst sqlite = new Database(\"nw.sqlite\");\nconst db: BunSQLiteDatabase = drizzle(sqlite);\nconst result = db.select(users).all()\n\n// Cloudflare D1 connector\nimport { drizzle, DrizzleD1Database } from 'drizzle-orm-sqlite/d1';\n\n// env.DB from cloudflare worker environment\nconst db: DrizzleD1Database = drizzle(env.DB);\nconst result = await db.select(users).all() // pay attention this one is async\n```\n\n## SQL schema declaration\nWith `drizzle-orm` you declare SQL schema in TypeScript. You can have either one `schema.ts` file with all declarations or you can group them logically in multiple files. We prefer to use single file schema.\n```\n📦project\n ├ 📂src\n │ ├ 📂data\n │ │ └ 📜schema.ts\n │ └ ...\n ├ ...\n └ 📜package.json\n \n## or multiple schema files\n├ 📂data\n  ├ 📜users.ts\n  ├ 📜countries.ts\n  ├ 📜cities.ts\n  ├ 📜products.ts\n  ├ 📜clients.ts\n  ├ 📜enums.ts\n  └ 📜etc.ts\n```\n\nThis is how you declare SQL schema in `schema.ts`. You can declare tables, indexes and constraints, foreign keys and enums. Please pay attention to `export` keyword, they are mandatory if you'll be using [drizzle-kit SQL migrations generator](#migrations).\n```typescript\nimport { sqliteTable, text, integer, uniqueIndex } from \"drizzle-orm-sqlite\";\n\nexport const countries = sqliteTable(\"countries\", {\n    id: integer(\"id\").primaryKey(),\n    name: text(\"name\"),\n  }, (table) => ({\n    nameIdx: uniqueIndex(\"nameIdx\").on(table.name),\n  })\n);\n\nexport const cities = sqliteTable(\"cities\", {\n  id: integer(\"id\").primaryKey(),\n  name: text(\"name\"),\n  countryId: integer(\"country_id\").references(() => countries.id),\n})\n```\n\nDatabase and table entity types\n```typescript\nimport { InferModel, text, integer, sqliteTable } from \"drizzle-orm-sqlite\";\n\nconst users = sqliteTable(\"users\", {\n  id: integer('id').primaryKey(),\n  fullName: text('full_name'),\n  phone: text('phone'),\n})\n\nexport type User = InferModel<typeof users> // return type when queried\nexport type InsertUser = InferModel<typeof users, \"insert\"> // insert type\n...\nimport { drizzle, BetterSQLite3Database } from 'drizzle-orm-sqlite/better-sqlite3';\nimport Database from \"better-sqlite3\";\n\nconst sqlite = new Database(\"sqlite.db\");\nconst db: BetterSQLite3Database = drizzle(sqlite);\n\nconst result: User[] = await db.select(users).all()\n\nconst insertUser = (user: InsertUser) => {\n  return db.insert(users).values(user).run()\n}\n```\n\n\nThe list of all column types. You can also create custom types - !!see here!!.\n```typescript\ninteger(\"...\")\ninteger(\"...\", { mode: \"number\" | \"timestamp\" | \"bigint\" })\nreal(\"...\")\ntext(\"...\");\ntext<\"union\" | \"string\" | \"type\">(\"...\");\n\nblob(\"...\");\nblob(\"...\", { mode: \"json\" | \"buffer\" });\nblob<{ foo: string }>(\"...\");\n\ncolumn.primaryKey()\ncolumn.notNull()\ncolumn.default(...)\n```\n\nDeclaring indexes, foreign keys and composite primary keys\n```typescript\nimport { sqliteTable, foreignKey, text, integer, index, uniqueIndex } from \"drizzle-orm-sqlite\";\n\nexport const countries = sqliteTable(\"countries\", {\n    id: integer(\"id\").primaryKey(),\n    name: text(\"name\", { length: 256 }),\n    population: integer(\"population\"),\n  }, (table) => ({\n    nameIdx: index(\"name_idx\").on(table.name), // one column\n    namePopulationIdx: index(\"name_population_idx\").on(table.name, table.population), // multiple columns\n    uniqueIdx: uniqueIndex(\"unique_idx\").on(table.name), // unique index\n  })\n);\n\nexport const cities = sqliteTable(\"cities\", {\n  id: integer(\"id\").primaryKey(),\n  name: text(\"name\", { length: 256 }),\n  countryId: integer(\"country_id\").references(() => countries.id), // inline foreign key\n  countryName: text(\"country_id\"),\n}, (table) => ({\n  // explicit foreign key with 1 column\n  countryFk: foreignKey(() => ({\n    columns: [table.countryId],\n    foreignColumns: [countries.id],\n  })),\n  // explicit foreign key with multiple columns\n  countryIdNameFk: foreignKey(() => ({\n    columns: [table.countryId, table.countryName],\n    foreignColumns: [countries.id, countries.name],\n  })),\n}));\n\nconst pkExample = sqliteTable('pk_example', {\n\tid: integer('id'),\n\tname: text('name').notNull(),\n\temail: text('email').notNull(),\n}, (table) => ({\n  // composite primary key on multiple columns\n\tcompositePk: primaryKey(table.id, table.name)\n}));\n\n// you can have .where() on indexes\nindex(\"name_idx\").on(table.name).where(sql``)\n```\n\n### Create Read Update Delete\nQuerying, sorting and filtering. We also support partial select.\n```typescript\n...\nimport { sqliteTable, text, integer } from \"drizzle-orm-sqlite\";\nimport { and, asc, desc, eq, or } from \"drizzle-orm/expressions\"\nimport { drizzle } from 'drizzle-orm-sqlite/better-sqlite3';\nimport Database from \"better-sqlite3\";\n\nconst users = sqliteTable(\"users\", {\n  id: integer(\"id\").primaryKey(),\n  name: text(\"full_name\"),\n});\n\nconst sqlite = new Database(\"sqlite.db\");\nconst db = drizzle(sqlite);\n\ndb.select(users).all();\ndb.select(users).where(eq(users.id, 42)).get();\n\n// you can combine filters with and(...) or or(...)\ndb.select(users).where(and(eq(users.id, 42), eq(users.name, \"Dan\"))).all();\n\ndb.select(users).where(or(eq(users.id, 42), eq(users.id, 1))).all();\n\n// partial select\nconst result = db.select(users).fields({\n    field1: users.id,\n    field2: users.name,\n  }).all();\nconst { field1, field2 } = result[0];\n\n// limit offset & order by\ndb.select(users).limit(10).offset(10).all();\ndb.select(users).orderBy(asc(users.name)).all();\ndb.select(users).orderBy(desc(users.name)).all();\n// you can pass multiple order args\ndb.select(users).orderBy(asc(users.name), desc(users.name)).all();\n\n// list of all filter operators\neq(column, value)\neq(column1, column2)\nne(column, value)\nne(column1, column2)\n\nnotEq(column, value)\nless(column, value)\nlessEq(column, value)\n\ngt(column, value)\ngt(column1, column2)\ngte(column, value)\ngte(column1, column2)\nlt(column, value)\nlt(column1, column2)\nlte(column, value)\nlte(column1, column2)\n\nisNull(column)\nisNotNull(column)\n\ninArray(column, values[])\ninArray(column, sqlSubquery)\nnotInArray(column, values[])\nnotInArray(column, sqlSubquery)\n\nexists(sqlSubquery)\nnotExists(sqlSubquery)\n\nbetween(column, min, max)\nnotBetween(column, min, max)\n\nlike(column, value)\nlike(column, value)\nilike(column, value)\nnotIlike(column, value)\n\nnot(sqlExpression)\n\nand(exressions: Expr[])\nor(exressions: Expr[])\n```\n\nInserting\n```typescript\nimport { sqliteTable, text, integer } from \"drizzle-orm-sqlite\";\nimport { drizzle } from 'drizzle-orm-sqlite/better-sqlite3';\nimport Database from \"better-sqlite3\";\n\nconst sqlite = new Database(\"sqlite.db\");\nconst db = drizzle(sqlite);\n\nconst users = sqliteTable(\"users\", {\n  id: integer(\"id\").primaryKey(),\n  name: text(\"name\"),\n  createdAt: integer(\"created_at\", { mode: \"timestamp\" }),\n});\n\ndb.insert(users).values({ name: \"Andrew\", createdAt: +new Date() }).run();\n\n// insert multiple users\ndb.insert(users).values({\n      name: \"Andrew\",\n      createdAt: +new Date(),\n    },{\n      name: \"Dan\",\n      createdAt: +new Date(),\n    }).run();\n\n// insert with returning\nconst insertedUser = db.insert(users).values({ name: \"Dan\", createdAt: +new Date() }).returning().get()\n```\n\nUpdate and Delete\n```typescript\ndb.update(users)\n  .set({ name: 'Mr. Dan' })\n  .where(eq(usersTable.name, 'Dan'))\n  .run();\n\t\ndb.delete(users)\n  .where(eq(usersTable.name, 'Dan'))\n  .run();\n```\n\n### Aggregations\nThey work just like they do in SQL, but you have them fully type safe\n```typescript\nconst orders = sqliteTable(\"order\", {\n  id: integer(\"id\").primaryKey(),\n  orderDate: integer(\"order_date\", { mode: \"timestamp\" }).notNull(),\n  requiredDate: integer(\"required_date\", { mode: \"timestamp\" }).notNull(),\n  shippedDate: integer(\"shipped_date\", { mode: \"timestamp\" }),\n  shipVia: integer(\"ship_via\").notNull(),\n  freight: numeric(\"freight\").notNull(),\n  shipName: text(\"ship_name\").notNull(),\n  shipCity: text(\"ship_city\").notNull(),\n  shipRegion: text(\"ship_region\"),\n  shipPostalCode: text(\"ship_postal_code\"),\n  shipCountry: text(\"ship_country\").notNull(),\n  customerId: text(\"customer_id\").notNull(),\n  employeeId: integer(\"employee_id\").notNull(),\n});\n\nconst details = sqliteTable(\"order_detail\", {\n  unitPrice: numeric(\"unit_price\").notNull(),\n  quantity: integer(\"quantity\").notNull(),\n  discount: numeric(\"discount\").notNull(),\n  orderId: integer(\"order_id\").notNull(),\n  productId: integer(\"product_id\").notNull(),\n});\n\n\ndb.select(orders).fields({\n    id: orders.id,\n    shippedDate: orders.shippedDate,\n    shipName: orders.shipName,\n    shipCity: orders.shipCity,\n    shipCountry: orders.shipCountry,\n    productsCount: sql`count(${details.productId})`.as<number>(),\n    quantitySum: sql`sum(${details.quantity})`.as<number>(),\n    totalPrice: sql`sum(${details.quantity} * ${details.unitPrice})`.as<number>(),\n  })\n  .leftJoin(details, eq(orders.id, details.orderId))\n  .groupBy(orders.id)\n  .orderBy(asc(orders.id))\n  .all();\n```\n\n\n### Joins\nLast but not least. Probably the most powerful feature in the library🚀\n### Many-to-one\n```typescript\nimport { sqliteTable, text, integer } from \"drizzle-orm-sqlite\";\nimport { drizzle } from 'drizzle-orm-sqlite/better-sqlite3';\n\nconst cities = sqliteTable(\"cities\", {\n  id: integer(\"id\").primaryKey(),\n  name: text(\"name\"),\n});\n\nconst users = sqliteTable(\"users\", {\n  id: integer(\"id\").primaryKey(),\n  name: text(\"name\"),\n  cityId: integer(\"city_id\").references(() => cities.id)\n});\n\nconst db = drizzle(sqlite);\n\nconst result = db.select(cities).leftJoin(users, eq(cities2.id, users2.cityId)).all()\n```\n\n### Many-to-many\n```typescript\nconst users = sqliteTable(\"users\", {\n  id: integer(\"id\").primaryKey(),\n  name: text(\"name\"),\n});\n\nconst chatGroups = sqliteTable(\"chat_groups\", {\n  id: integer(\"id\").primaryKey(),\n  name: text(\"name\"),\n});\n\nconst usersToChatGroups = sqliteTable(\"usersToChatGroups\", {\n  userId: integer(\"user_id\").notNull().references(() => users.id),\n  groupId: integer(\"group_id\").notNull().references(() => chatGroups.id),\n});\n\n...\nconst db = drizzle(...);\n\n// querying user group with id 1 and all the participants(users)\ndb.select(usersToChatGroups)\n  .leftJoin(users, eq(usersToChatGroups.userId, users.id))\n  .leftJoin(chatGroups, eq(usersToChatGroups.groupId, chatGroups.id))\n  .where(eq(chatGroups.id, 1))\n  .all();\n```\n\n### Join aliases and selfjoins\n```typescript\nimport { ..., alias } from \"drizzle-orm-sqlite\";\n\nexport const files = sqliteTable(\"folders\", {\n  name: text(\"name\").notNull(),\n  parent: text(\"parent_folder\")\n})\n\n...\nconst db = drizzle(...);\n\nconst nestedFiles = alias(files, \"nested_files\");\ndb.select(files)\n  .leftJoin(nestedFiles, eq(files.name, nestedFiles.name))\n  .where(eq(files.parent, \"/\"))\n  .all();\n// will return files and folers and nested files for each folder at root dir\n```\n\n### Join using partial field select\nJoin Cities with Users getting only needed fields form request\n```typescript\ndb.select(cities).fields({\n  id: cities.id,\n  cityName: cities.name\n  userId: users.id\n}).leftJoin(users, eq(users.cityId, cities.id))\n  .all();\n```\n\n## ⚡️ Performance and prepared statements\nWith Drizzle ORM you can go [**faster than better-sqlite3 driver**](https://twitter.com/_alexblokh/status/1593593415907909634) by utilizing our `prepared statements` and `placeholder` APIs\n```typescript\nimport { placeholder } from \"drizzle-orm/sql\";\n\nconst db = drizzle(...);\n\nconst q = db.select(customers).prepare();\nq.all() // SELECT * FROM customers\n\nconst q = db.select(customers).where(eq(customers.id, placeholder(\"id\"))).prepare()\n\nq.get({ id: 10 }) // SELECT * FROM customers WHERE id = 10\nq.get({ id: 12 }) // SELECT * FROM customers WHERE id = 12\n\nconst q = db.select(customers)\n  .where(sql`lower(${customers.name}) like ${placeholder(\"name\")}`)\n  .prepare();\n\nq.all({ name: \"%an%\" }) // SELECT * FROM customers WHERE name ilike '%an%'\n```\n\n## 🗄 Migrations\n### Automatic SQL migrations generation with drizzle-kit\n[DrizzleKit](https://www.npmjs.com/package/drizzle-kit) - is a CLI migrator tool for DrizzleORM. It is probably one and only tool that lets you completely automatically generate SQL migrations and covers ~95% of the common cases like delitions and renames by prompting user input.\\\nCheck out the [docs for DrizzleKit](https://github.com/drizzle-team/drizzle-kit-mirror)\n\nFor schema file:\n```typescript\nimport { index, integer, sqliteTable, text } from \"drizzle-orm-sqlite\";\n\nexport const users = sqliteTable(\"users\", {\n  id: serial(\"id\").primaryKey(),\n  fullName: text(\"full_name\"),\n}, (table)=>({\n  nameIdx: index(\"name_idx\", table.fullName),\n}));\n\nexport const authOtps = sqliteTable(\"auth_otp\", {\n  id: integer(\"id\").primaryKey(),\n  phone: text(\"phone\"),\n  userId: integer(\"user_id\").references(() => users.id),\n}\n```\nIt will generate:\n```SQL\nCREATE TABLE IF NOT EXISTS auth_otp (\n\t\"id\" INTEGER PRIMARY KEY,\n\t\"phone\" TEXT,\n\t\"user_id\" INTEGER\n);\n\nCREATE TABLE IF NOT EXISTS users (\n\t\"id\" INTEGER PRIMARY KEY,\n\t\"full_name\" TEXT\n);\n\nDO $$ BEGIN\n ALTER TABLE auth_otp ADD CONSTRAINT auth_otp_user_id_fkey FOREIGN KEY (\"user_id\") REFERENCES users(id);\nEXCEPTION\n WHEN duplicate_object THEN null;\nEND $$;\n\nCREATE INDEX IF NOT EXISTS users_full_name_index ON users (full_name);\n```\n\nAnd you can run migrations manually or using our embedded migrations module\n```typescript\nimport { drizzle } from 'drizzle-orm-sqlite/better-sqlite3';\nimport { migrate } from 'drizzle-orm-sqlite/better-sqlite3/migrator';\nimport Database from \"better-sqlite3\";\n\nconst sqlite = new Database(\"sqlite.db\");\nconst db = drizzle(sqlite);\n\n// this will automatically run needed migrations on the database\nmigrate(db, { migrationsFolder: \"./drizzle\" })\n```\n\n## Utility stuff\n### Printing SQL query\n```typescript\nconst query = db.select(users)\n\t\t.fields({ id: users.id, name: users.name })\n\t\t.groupBy(users.id)\n\t\t.toSQL();\n// query:\n{\n  sql: 'select \"id\", \"name\" from \"users\" group by \"users\".\"id\"',\n  params: [],\n}\n``` \n\n### Raw query usage\n```typescript\n// it will automatically run a parametrized query!\nconst res: QueryResult<any> = await db.run(sql`SELECT * FROM users WHERE user.id = ${userId}`)\n```\n","license":"Apache-2.0","scripts":{"pack":"(cd dist && pnpm pack --pack-destination ..) && rm -f package.tgz && mv *.tgz package.tgz","build":"tsc -p tsconfig.build.json && resolve-tspaths && cp README.md package.json dist/","release":"pnpm build && pnpm run pack && pnpm run publish","test:types":"cd tests && tsc","release:beta":"pnpm build && pnpm run pack && pnpm run publish --tag beta"},"_npmUser":{"name":"dankochetov","email":"danil.kochetov@gmail.com"},"homepage":"https://github.com/drizzle-team/drizzle-orm#readme","keywords":["orm","sqlite","database","sql","typescript"],"_resolved":"/home/runner/work/drizzle-orm/drizzle-orm/drizzle-orm-sqlite/package.tgz","_integrity":"sha512-Qq9M41SXc7M8L0LISzzcX/exCgKByMbh7F0uplAEjdn6zn0HnvmmRnN36FWktmnds2dmyeowJSYXwUaynigCRw==","deprecated":"This package is merged into drizzle-orm starting from 0.17.0. See https://www.npmjs.com/package/drizzle-orm","repository":{"url":"git+https://github.com/drizzle-team/drizzle-orm.git","type":"git"},"_npmVersion":"8.19.3","description":"Drizzle ORM package for SQLite database","directories":{},"maintainers":[{"name":"alexblokh","email":"aleksandrblokh@gmail.com"},{"name":"sheriman","email":"andreysherman11@gmail.com"},{"name":"dankochetov","email":"danil.kochetov@gmail.com"}],"_nodeVersion":"16.19.0","_hasShrinkwrap":false,"readmeFilename":"README.md","devDependencies":{"sqlite3":"^5.1.2","drizzle-orm":"link:../drizzle-orm/dist","better-sqlite3":"^7.6.2","@types/better-sqlite3":"^7.6.2","@cloudflare/workers-types":"^3.18.0"},"peerDependencies":{"sqlite3":">=5 <6","drizzle-orm":">=0.15 <0.16","better-sqlite3":">=7 <9","@types/better-sqlite3":">=7 <9","@cloudflare/workers-types":">=3"},"peerDependenciesMeta":{"sqlite3":{"optional":true},"better-sqlite3":{"optional":true},"@types/better-sqlite3":{"optional":true},"@cloudflare/workers-types":{"optional":true}},"_npmOperationalInternal":{"tmp":"tmp/drizzle-orm-sqlite_0.15.2_1673878062583_0.3885510856942842","host":"s3://npm-registry-packages"},"_id":"drizzle-orm-sqlite@0.15.2","version":"0.15.2"}