@forinda/kickjs-db 8.8.0 → 8.10.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (61) hide show
  1. package/dist/adapter-DKRmIatU.d.mts +69 -0
  2. package/dist/adapter-DKRmIatU.d.mts.map +1 -0
  3. package/dist/cli.d.mts +4 -2
  4. package/dist/cli.d.mts.map +1 -1
  5. package/dist/cli.mjs +4 -4
  6. package/dist/cli.mjs.map +1 -1
  7. package/dist/create-Dxv1CmO0.mjs +31 -0
  8. package/dist/create-Dxv1CmO0.mjs.map +1 -0
  9. package/dist/custom-type-0v1pEaSz.mjs +12 -0
  10. package/dist/custom-type-0v1pEaSz.mjs.map +1 -0
  11. package/dist/devtools-events.d.mts +1 -1
  12. package/dist/devtools-events.mjs +1 -1
  13. package/dist/{index-sRSu3kiL.d.mts → index-D98BJCWj.d.mts} +78 -20
  14. package/dist/index-D98BJCWj.d.mts.map +1 -0
  15. package/dist/index.d.mts +6 -6
  16. package/dist/index.mjs +2 -2
  17. package/dist/mysql.d.mts +2 -2
  18. package/dist/mysql.mjs +8 -6
  19. package/dist/mysql.mjs.map +1 -1
  20. package/dist/{pg-CJr6OX2u.mjs → pg-CsEZYRUy.mjs} +3 -3
  21. package/dist/{pg-CJr6OX2u.mjs.map → pg-CsEZYRUy.mjs.map} +1 -1
  22. package/dist/pg.d.mts +5 -69
  23. package/dist/pg.d.mts.map +1 -1
  24. package/dist/pg.mjs +9 -6
  25. package/dist/pg.mjs.map +1 -1
  26. package/dist/pglite.d.mts +39 -0
  27. package/dist/pglite.d.mts.map +1 -0
  28. package/dist/pglite.mjs +12 -0
  29. package/dist/pglite.mjs.map +1 -0
  30. package/dist/{schema-BP_TZ1Sv.d.mts → schema-Cl1eDPkD.d.mts} +3 -3
  31. package/dist/{schema-BP_TZ1Sv.d.mts.map → schema-Cl1eDPkD.d.mts.map} +1 -1
  32. package/dist/{schema-types-DqdkKV19.d.mts → schema-types-BMUMDpUC.d.mts} +3 -3
  33. package/dist/{schema-types-DqdkKV19.d.mts.map → schema-types-BMUMDpUC.d.mts.map} +1 -1
  34. package/dist/schema.d.mts +1 -1
  35. package/dist/schema.mjs +2 -2
  36. package/dist/{split-statements-E5gaoZIS.mjs → split-statements-DSWCQZGv.mjs} +2 -2
  37. package/dist/{split-statements-E5gaoZIS.mjs.map → split-statements-DSWCQZGv.mjs.map} +1 -1
  38. package/dist/sqlite.d.mts +1 -1
  39. package/dist/sqlite.d.mts.map +1 -1
  40. package/dist/sqlite.mjs +9 -7
  41. package/dist/sqlite.mjs.map +1 -1
  42. package/dist/src-C0egEVT1.mjs +203 -0
  43. package/dist/src-C0egEVT1.mjs.map +1 -0
  44. package/dist/{table-xq-X29gB.d.mts → table-xb127l8S.d.mts} +2 -2
  45. package/dist/{table-xq-X29gB.d.mts.map → table-xb127l8S.d.mts.map} +1 -1
  46. package/dist/testing.d.mts +2 -2
  47. package/dist/testing.mjs +2 -2
  48. package/dist/{types-ydAqBLR1.d.mts → types-BosmVkt_.d.mts} +82 -11
  49. package/dist/types-BosmVkt_.d.mts.map +1 -0
  50. package/dist/{types-LCdRbLC1.d.mts → types-CBoxFMRg.d.mts} +13 -1
  51. package/dist/types-CBoxFMRg.d.mts.map +1 -0
  52. package/package.json +15 -6
  53. package/dist/create-K_h9SGPl.mjs +0 -29
  54. package/dist/create-K_h9SGPl.mjs.map +0 -1
  55. package/dist/custom-type-BPJpUuWz.mjs +0 -12
  56. package/dist/custom-type-BPJpUuWz.mjs.map +0 -1
  57. package/dist/index-sRSu3kiL.d.mts.map +0 -1
  58. package/dist/src-TXge_81j.mjs +0 -200
  59. package/dist/src-TXge_81j.mjs.map +0 -1
  60. package/dist/types-LCdRbLC1.d.mts.map +0 -1
  61. package/dist/types-ydAqBLR1.d.mts.map +0 -1
@@ -1,12 +0,0 @@
1
- /**
2
- * @forinda/kickjs-db v8.8.0
3
- *
4
- * Copyright (c) Felix Orinda
5
- *
6
- * This source code is licensed under the MIT license found in the
7
- * LICENSE file in the root directory of this source tree.
8
- *
9
- * @license MIT
10
- */
11
- const KICK_GENERATED=Symbol.for(`@forinda/kickjs-db/Generated`),KICK_NOT_NULL=Symbol.for(`@forinda/kickjs-db/NotNull`);var ColumnBuilder=class{state;constructor(type,defaults={}){this.state={type,nullable:defaults.nullable??!0,default:defaults.default??null,primaryKey:defaults.primaryKey??!1,unique:defaults.unique??!1,references:defaults.references??null,...defaults.mode?{mode:defaults.mode}:{}}}notNull(){return this.state.nullable=!1,this}primaryKey(){return this.state.primaryKey=!0,this.state.nullable=!1,this}unique(){return this.state.unique=!0,this}array(){return this.state.type=`${this.state.type}[]`,this}references(target,opts={}){return this.state.references={thunk:target,onDelete:opts.onDelete??`no_action`,onUpdate:opts.onUpdate??`no_action`,...opts.name===void 0?{}:{name:opts.name}},this}default(value){return this.state.default=typeof value==`string`?value:String(value),this}$defaultFn(fn){return this.state.defaultFn=fn,this}$onUpdate(fn){return this.state.onUpdateFn=fn,this}onUpdateNow(){return this.state.managed=`updatedAt`,this}softDelete(){return this.state.managed=`softDelete`,this}generatedAlwaysAs(expression,options={}){return this.state.generated={expression,stored:options.stored??!0},this}generatedAlwaysAsIdentity(){return this.state.identity=`always`,this.state.nullable=!1,this}generatedByDefaultAsIdentity(){return this.state.identity=`byDefault`,this.state.nullable=!1,this}comment(text){return this.state.comment=text,this}colName(name){return this.state.colName=name,this}managedAs(){return this.state.managed}toJSON(name){return{name,type:this.state.type,nullable:this.state.nullable,default:this.state.default,primaryKey:this.state.primaryKey,...this.state.generated?{generated:{...this.state.generated}}:{},...this.state.identity?{identity:this.state.identity}:{},...this.state.comment===void 0?{}:{comment:this.state.comment}}}__state(){return this.state}},CustomColumnBuilder=class extends ColumnBuilder{toDriver;fromDriver;constructor(opts){super(opts.dataType()),this.toDriver=opts.toDriver,this.fromDriver=opts.fromDriver}};function customType(opts){return()=>new CustomColumnBuilder(opts)}export{KICK_NOT_NULL as a,KICK_GENERATED as i,customType as n,ColumnBuilder as r,CustomColumnBuilder as t};
12
- //# sourceMappingURL=custom-type-BPJpUuWz.mjs.map
@@ -1 +0,0 @@
1
- {"version":3,"file":"custom-type-BPJpUuWz.mjs","names":[],"sources":["../src/dsl/columns/types.ts","../src/custom-type.ts"],"sourcesContent":["import type { ColumnSnapshot, FkAction } from '../../snapshot/types'\n\n/**\n * Runtime + type representation of a column reference (e.g. `users.id`).\n * Carries the parent table name, the column's own name, plus runtime\n * accessors used by FK thunks and constraint builders.\n *\n * Exported so adopters can annotate self-referencing thunks without\n * spelling the shape inline:\n *\n * parentId: uuid().references((): ColumnRef => categories.id)\n *\n * Without the annotation the initializer of a self-referencing const\n * trips TS7022 — TS needs to infer the const while the initializer\n * already references it.\n */\nexport interface ColumnRef {\n __tableName: string\n __name: string\n __builder: ColumnBuilder\n __state: () => ReturnType<ColumnBuilder['__state']>\n}\n\n/**\n * Resolved FK spec — `table` / `column` are pulled by invoking `thunk()`\n * lazily. The thunk pattern lets self-referencing tables work:\n *\n * const categories = table('categories', {\n * id: uuid().primaryKey().defaultRandom(),\n * parentId: uuid().references((): ColumnRef => categories.id),\n * })\n *\n * If we resolved at `.references()` call time, `categories` would TDZ-fail\n * inside its own initializer. Storing the thunk and resolving on read\n * (extract / render / emit) defers until after the const binding lands.\n */\n/**\n * A column ref that knows its column's value type — what lets a foreign key\n * be checked against the column it points at (`fk()`). Assignable to\n * `ColumnRef`, so every existing ref-taking API keeps working.\n */\nexport type TypedColumnRef<T> = ColumnRef & { readonly __valueType?: T }\n\n/** Typed refs for a column record — one per column. */\nexport type TypedColumnRefs<C> = {\n [K in keyof C]: TypedColumnRef<C[K] extends ColumnBuilder<infer T> ? T : never>\n}\n\nexport interface FkSpec {\n thunk: () => ColumnRef\n onDelete: FkAction\n onUpdate: FkAction\n /**\n * The constraint's name in the database.\n *\n * Omitted for schemas written by hand — the name is then derived as\n * `<table>_<column>_fk`. It is set when the schema was generated by\n * `kick db introspect`, because a database names its constraints itself:\n * Postgres' own default is `<table>_<column>_fkey`, and a DBA may have\n * chosen anything. Dropping the real name would make the next diff want to\n * rename every foreign key in the schema.\n */\n name?: string\n}\n\nexport interface ColumnState {\n type: string\n nullable: boolean\n default: string | null\n primaryKey: boolean\n unique: boolean\n references: FkSpec | null\n /**\n * A column kick/db maintains itself: `'updatedAt'` (set on every update),\n * `'version'` (incremented on every update), `'softDelete'` (rows with it\n * set are skipped by relational reads). Never part of the snapshot — it\n * changes queries, not the schema.\n */\n managed?: 'updatedAt' | 'version' | 'softDelete'\n generated?: { expression: string; stored: boolean }\n identity?: 'always' | 'byDefault'\n /**\n * How a bigint / numeric value is read back (`bigint({ mode })`,\n * `numeric(p, s, { mode })`). Unset, the driver's own value is returned.\n */\n mode?: 'bigint' | 'number' | 'string'\n /** `.comment()`: stored in the database on Postgres and MySQL. */\n comment?: string\n /** `.colName()`: the column's name in the database, when it isn't the key (or its `casing`). */\n colName?: string\n /** `tenantKey(tenancy)`: this is the table's tenant column. */\n tenancy?: { strategy: string; setting: string }\n /** `$defaultFn`: computed in JS for each inserted row that doesn't set it. */\n defaultFn?: () => unknown\n /** `$onUpdate`: computed in JS for each update that doesn't set it. */\n onUpdateFn?: () => unknown\n}\n\n/**\n * Type-only brand attached to a column when it's auto-assigned by the\n * database (serial / bigserial / smallserial), has a runtime default\n * (`.default(...)`), or carries an expression default\n * (`uuid().defaultRandom()`, `timestamp().defaultNow()`). `SchemaToTypes<S>`\n * reads this marker and wraps the column type in Kysely's `Generated<T>` so\n * adopters can omit the column on insert.\n *\n * Runtime is a no-op — the symbol never reaches a value.\n */\nexport const KICK_GENERATED = Symbol.for('@forinda/kickjs-db/Generated')\nexport type GeneratedBrand = { readonly [KICK_GENERATED]?: true }\n\n/**\n * Type-only brand for a column the database always computes — a generated\n * column, or an identity `GENERATED ALWAYS`. `SchemaToTypes<S>` wraps it in\n * Kysely's `GeneratedAlways<T>`, so it can't be inserted or updated.\n */\nexport const KICK_GENERATED_ALWAYS = Symbol.for('@forinda/kickjs-db/GeneratedAlways')\nexport type GeneratedAlwaysBrand = { readonly [KICK_GENERATED_ALWAYS]?: true }\n\n/**\n * Type-only brand attached to a column when `.notNull()` or `.primaryKey()`\n * is called. `SchemaToTypes<S>` reads this brand to decide whether the\n * column type is `T` (NOT NULL) or `T | null` (default nullable).\n *\n * Why a brand instead of a class generic: chained methods (notNull,\n * primaryKey) can return `this & NotNullBrand` to narrow nullability while\n * preserving the subclass identity — so `uuid().primaryKey().defaultRandom()`\n * still resolves `defaultRandom()` on `UuidBuilder`. A class generic\n * `<TNullable>` would collapse the subclass back to the parent.\n */\nexport const KICK_NOT_NULL = Symbol.for('@forinda/kickjs-db/NotNull')\nexport type NotNullBrand = { readonly [KICK_NOT_NULL]?: true }\n\n/**\n * Re-attach the nullability / generated brands after a transform that\n * must return a *new* builder type (e.g. `.array()` widening `T` to\n * `T[]`). Without this, `integer().notNull().array()` silently dropped\n * `NotNullBrand` and the row type regressed to `number[] | null`.\n *\n * Uses the same `extends` checks as `SchemaToTypes` (client/schema-types.ts)\n * so detection stays consistent in both directions.\n */\nexport type PreserveBrands<Self, Out> = Out &\n (Self extends NotNullBrand ? NotNullBrand : unknown) &\n (Self extends GeneratedBrand ? GeneratedBrand : unknown) &\n (Self extends GeneratedAlwaysBrand ? GeneratedAlwaysBrand : unknown)\n\n/**\n * Phantom-typed column builder. The `T` generic carries the column's TS\n * value type (number / string / Date / etc.); nullability is tracked via\n * the `NotNullBrand` intersection rather than a class generic so chain\n * methods preserve subclass identity.\n *\n * Both `T` and the brand are erased at runtime; they exist purely so\n * `SchemaToTypes<S>` can pull them out per column.\n */\nexport class ColumnBuilder<T = unknown> {\n // Phantom param shows up in the public surface so the type system sees\n // it. Reading it at runtime is intentionally not supported.\n declare readonly __t?: T\n\n protected state: ColumnState\n\n constructor(type: string, defaults: Partial<ColumnState> = {}) {\n this.state = {\n type,\n nullable: defaults.nullable ?? true,\n default: defaults.default ?? null,\n primaryKey: defaults.primaryKey ?? false,\n unique: defaults.unique ?? false,\n references: defaults.references ?? null,\n ...(defaults.mode ? { mode: defaults.mode } : {}),\n }\n }\n\n notNull(): this & NotNullBrand {\n this.state.nullable = false\n return this as this & NotNullBrand\n }\n\n primaryKey(): this & NotNullBrand {\n this.state.primaryKey = true\n this.state.nullable = false\n return this as this & NotNullBrand\n }\n\n unique(): this {\n this.state.unique = true\n return this\n }\n\n array(): PreserveBrands<this, ColumnBuilder<T[]>> {\n this.state.type = `${this.state.type}[]`\n return this as unknown as PreserveBrands<this, ColumnBuilder<T[]>>\n }\n\n references(\n target: () => ColumnRef,\n opts: { onDelete?: FkAction; onUpdate?: FkAction; name?: string } = {},\n ): this {\n // Store the thunk — do NOT invoke it here. Self-referencing tables\n // pass `() => self.id` whose binding does not exist yet.\n this.state.references = {\n thunk: target,\n onDelete: opts.onDelete ?? 'no_action',\n onUpdate: opts.onUpdate ?? 'no_action',\n // Only carried when given: an absent name means \"derive it\", and\n // storing the derived value here would make it indistinguishable from\n // an explicit one that happens to match.\n ...(opts.name === undefined ? {} : { name: opts.name }),\n }\n return this\n }\n\n /**\n * Mark the column as having a runtime / DB-assigned default. The\n * `GeneratedBrand` flows into `SchemaToTypes<S>` so the column wraps\n * in `Generated<T>` — adopters can `INSERT` without specifying it.\n *\n * Accepts the natural literal for the column type — `boolean().default(false)`,\n * `integer().default(0)`, `varchar().default('active')`. Non-string\n * literals are normalised to their SQL-literal text so the snapshot\n * (`ColumnSnapshot.default: string | null`) and migration emitter stay\n * string-only. For a quoted string default the text is the value\n * itself (`'active'`); booleans/numbers emit bare (`false`, `0`).\n */\n default(value: string | number | boolean): this & GeneratedBrand {\n this.state.default = typeof value === 'string' ? value : String(value)\n return this as this & GeneratedBrand\n }\n\n /**\n * A default computed in JS for each inserted row that doesn't set this\n * column — an id generator, a slug, a value from config:\n * `id: text().primaryKey().$defaultFn(() => ulid())`. Not part of the\n * schema: the database has no default, so raw SQL inserts must set it.\n */\n $defaultFn(fn: () => T): this & GeneratedBrand {\n this.state.defaultFn = fn\n return this as this & GeneratedBrand\n }\n\n /**\n * A value computed in JS for each update (and an upsert's update branch)\n * that doesn't set this column: `revisedBy: text().$onUpdate(() => currentUser())`.\n * Like `onUpdateNow()`, with your own value. Inserts don't call it.\n */\n $onUpdate(fn: () => T): this {\n this.state.onUpdateFn = fn\n return this\n }\n\n /**\n * Set this column to the current time on every update that doesn't set it\n * itself — `updatedAt: timestamp().notNull().defaultNow().onUpdateNow()`.\n */\n onUpdateNow(): this {\n this.state.managed = 'updatedAt'\n return this\n }\n\n /**\n * Mark this column — a nullable timestamp — as the soft-delete marker:\n * relational reads (`db.query`) skip rows where it's set, at every level,\n * unless asked `withDeleted: true`. Soft-delete by setting it.\n */\n softDelete(): this {\n this.state.managed = 'softDelete'\n return this\n }\n\n /**\n * Computed by the database from other columns, on every write:\n * `total: numeric(12, 2).generatedAlwaysAs('price * quantity')`. The SQL is\n * passed through as written. Stored by default; `{ stored: false }` makes\n * it virtual, computed on read (MySQL, SQLite, Postgres 18+). It can't be\n * inserted or updated.\n */\n generatedAlwaysAs(\n expression: string,\n options: { stored?: boolean } = {},\n ): this & GeneratedAlwaysBrand {\n this.state.generated = { expression, stored: options.stored ?? true }\n return this as this & GeneratedAlwaysBrand\n }\n\n /**\n * An identity column the database numbers and won't let you set (Postgres)\n * — the SQL-standard successor to `serial`.\n */\n generatedAlwaysAsIdentity(): this & NotNullBrand & GeneratedAlwaysBrand {\n this.state.identity = 'always'\n this.state.nullable = false\n return this as this & NotNullBrand & GeneratedAlwaysBrand\n }\n\n /** An identity column the database numbers unless a value is given (Postgres). */\n generatedByDefaultAsIdentity(): this & NotNullBrand & GeneratedBrand {\n this.state.identity = 'byDefault'\n this.state.nullable = false\n return this as this & NotNullBrand & GeneratedBrand\n }\n\n /**\n * A comment stored with the column in the database, for whoever reads the\n * schema there (Postgres, MySQL; SQLite has none). Changing it migrates.\n */\n comment(text: string): this {\n this.state.comment = text\n return this\n }\n\n /**\n * The column's name in the database, when it isn't the key — a legacy\n * `EMAIL_ADDR` behind an `email` key. Taken as written: `casing` doesn't\n * change it. Queries, `db.query` and migrations use it; your code keeps the key.\n */\n colName(name: string): this {\n this.state.colName = name\n return this\n }\n\n /** The role kick/db maintains this column in, if any. */\n managedAs(): ColumnState['managed'] {\n return this.state.managed\n }\n\n toJSON(name: string): ColumnSnapshot {\n return {\n name,\n type: this.state.type,\n nullable: this.state.nullable,\n default: this.state.default,\n primaryKey: this.state.primaryKey,\n // Only when set, so other columns serialize as they always have.\n ...(this.state.generated ? { generated: { ...this.state.generated } } : {}),\n ...(this.state.identity ? { identity: this.state.identity } : {}),\n ...(this.state.comment !== undefined ? { comment: this.state.comment } : {}),\n }\n }\n\n // Internal accessor for table()/diff to read full state including unique/references.\n __state(): Readonly<ColumnState> {\n return this.state\n }\n}\n","// customType<T>() — adopter-defined column type with optional driver\n// codecs. Lets a project introduce a typed column that doesn't ship\n// in the built-in DSL (encrypted strings, custom JSON shapes, citext,\n// PostGIS geometry, etc.) without forking the package.\n//\n// Schema usage:\n//\n// const encrypted = customType<EncryptedString>({\n// dataType: () => 'text',\n// toDriver: (s) => encrypt(s),\n// fromDriver: (raw) => decrypt(String(raw)),\n// })\n//\n// export const secrets = table('secrets', {\n// id: serial().primaryKey(),\n// value: encrypted().notNull(),\n// })\n//\n// `SchemaToTypes<typeof schema>` reads the phantom T from the\n// CustomColumnBuilder so `db.selectFrom('secrets').select('value')`\n// types `value: EncryptedString` (not `string`). Driver codecs flow\n// through the lifecycle plugin landing in M2.F-T19; until then they\n// are stored on the builder for the runtime hookup to pick up.\n\nimport { ColumnBuilder } from './dsl/columns/types'\n\nexport interface CustomTypeOptions<TJs, TDriver = unknown> {\n /**\n * SQL data type as it would appear in `CREATE TABLE` — `'text'`,\n * `'jsonb'`, `'citext'`, `'geometry(Point, 4326)'`, etc. Returned\n * via a thunk so adopters can compute the type from runtime config\n * (e.g. dialect-specific overrides).\n */\n dataType: () => string\n /** Optional encode hook applied at insert / update time. */\n toDriver?: (value: TJs) => TDriver\n /** Optional decode hook applied to selected rows. */\n fromDriver?: (driver: TDriver) => TJs\n}\n\n/**\n * ColumnBuilder subclass produced by `customType()`. Carries the\n * driver codecs so the (future) hooks pipeline can wire them through\n * a Kysely plugin without each consumer re-declaring its mapping.\n *\n * The phantom `T` flows through `SchemaToTypes<S>` exactly like any\n * other ColumnBuilder<T>, so adopters get full row-shape inference\n * for free.\n */\nexport class CustomColumnBuilder<TJs> extends ColumnBuilder<TJs> {\n /** Encode hook — run on values heading into the database. */\n readonly toDriver?: (value: TJs) => unknown\n /** Decode hook — run on row values coming out of the database. */\n readonly fromDriver?: (driver: unknown) => TJs\n\n constructor(opts: CustomTypeOptions<TJs>) {\n super(opts.dataType())\n this.toDriver = opts.toDriver as never\n this.fromDriver = opts.fromDriver as never\n }\n}\n\n/**\n * Build a reusable column factory for a custom type. The returned\n * function is what callers use inside `table('foo', { col: factory() })`\n * — same shape as the built-in `varchar()`, `text()`, etc.\n *\n * @example\n * ```ts\n * const ulid = customType<string>({\n * dataType: () => 'char(26)',\n * toDriver: (s) => s,\n * fromDriver: (raw) => String(raw),\n * })\n *\n * const events = table('events', {\n * id: ulid().primaryKey(),\n * ts: timestamp().notNull().defaultNow(),\n * })\n * ```\n */\nexport function customType<TJs>(opts: CustomTypeOptions<TJs>): () => CustomColumnBuilder<TJs> {\n return () => new CustomColumnBuilder<TJs>(opts)\n}\n"],"mappings":";;;;;;;;;;AA4GA,MAAa,eAAiB,OAAO,IAAI,8BAA8B,EAsB1D,cAAgB,OAAO,IAAI,4BAA4B,EA0BpE,IAAa,cAAb,KAAwC,CAKtC,MAEA,YAAY,KAAc,SAAiC,CAAC,EAAG,CAC7D,KAAK,MAAQ,CACX,KACA,SAAU,SAAS,UAAY,GAC/B,QAAS,SAAS,SAAW,KAC7B,WAAY,SAAS,YAAc,GACnC,OAAQ,SAAS,QAAU,GAC3B,WAAY,SAAS,YAAc,KACnC,GAAI,SAAS,KAAO,CAAE,KAAM,SAAS,IAAK,EAAI,CAAC,CACjD,CACF,CAEA,SAA+B,CAE7B,MADA,MAAK,MAAM,SAAW,GACf,IACT,CAEA,YAAkC,CAGhC,MAFA,MAAK,MAAM,WAAa,GACxB,KAAK,MAAM,SAAW,GACf,IACT,CAEA,QAAe,CAEb,MADA,MAAK,MAAM,OAAS,GACb,IACT,CAEA,OAAkD,CAEhD,MADA,MAAK,MAAM,KAAO,GAAG,KAAK,MAAM,KAAK,IAC9B,IACT,CAEA,WACE,OACA,KAAoE,CAAC,EAC/D,CAYN,MATA,MAAK,MAAM,WAAa,CACtB,MAAO,OACP,SAAU,KAAK,UAAY,YAC3B,SAAU,KAAK,UAAY,YAI3B,GAAI,KAAK,OAAS,IAAA,GAAY,CAAC,EAAI,CAAE,KAAM,KAAK,IAAK,CACvD,EACO,IACT,CAcA,QAAQ,MAAyD,CAE/D,MADA,MAAK,MAAM,QAAU,OAAO,OAAU,SAAW,MAAQ,OAAO,KAAK,EAC9D,IACT,CAQA,WAAW,GAAoC,CAE7C,MADA,MAAK,MAAM,UAAY,GAChB,IACT,CAOA,UAAU,GAAmB,CAE3B,MADA,MAAK,MAAM,WAAa,GACjB,IACT,CAMA,aAAoB,CAElB,MADA,MAAK,MAAM,QAAU,YACd,IACT,CAOA,YAAmB,CAEjB,MADA,MAAK,MAAM,QAAU,aACd,IACT,CASA,kBACE,WACA,QAAgC,CAAC,EACJ,CAE7B,MADA,MAAK,MAAM,UAAY,CAAE,WAAY,OAAQ,QAAQ,QAAU,EAAK,EAC7D,IACT,CAMA,2BAAwE,CAGtE,MAFA,MAAK,MAAM,SAAW,SACtB,KAAK,MAAM,SAAW,GACf,IACT,CAGA,8BAAqE,CAGnE,MAFA,MAAK,MAAM,SAAW,YACtB,KAAK,MAAM,SAAW,GACf,IACT,CAMA,QAAQ,KAAoB,CAE1B,MADA,MAAK,MAAM,QAAU,KACd,IACT,CAOA,QAAQ,KAAoB,CAE1B,MADA,MAAK,MAAM,QAAU,KACd,IACT,CAGA,WAAoC,CAClC,OAAO,KAAK,MAAM,OACpB,CAEA,OAAO,KAA8B,CACnC,MAAO,CACL,KACA,KAAM,KAAK,MAAM,KACjB,SAAU,KAAK,MAAM,SACrB,QAAS,KAAK,MAAM,QACpB,WAAY,KAAK,MAAM,WAEvB,GAAI,KAAK,MAAM,UAAY,CAAE,UAAW,CAAE,GAAG,KAAK,MAAM,SAAU,CAAE,EAAI,CAAC,EACzE,GAAI,KAAK,MAAM,SAAW,CAAE,SAAU,KAAK,MAAM,QAAS,EAAI,CAAC,EAC/D,GAAI,KAAK,MAAM,UAAY,IAAA,GAA8C,CAAC,EAAnC,CAAE,QAAS,KAAK,MAAM,OAAQ,CACvE,CACF,CAGA,SAAiC,CAC/B,OAAO,KAAK,KACd,CACF,ECxSa,oBAAb,cAA8C,aAAmB,CAE/D,SAEA,WAEA,YAAY,KAA8B,CACxC,MAAM,KAAK,SAAS,CAAC,EACrB,KAAK,SAAW,KAAK,SACrB,KAAK,WAAa,KAAK,UACzB,CACF,EAqBA,SAAgB,WAAgB,KAA8D,CAC5F,UAAa,IAAI,oBAAyB,IAAI,CAChD"}
@@ -1 +0,0 @@
1
- {"version":3,"file":"index-sRSu3kiL.d.mts","names":["Dialect","Dialect","Dialect","Dialect","Dialect","Dialect"],"sources":["../src/migrate/adapter.ts","../src/migrate/drift.ts","../src/cli/config.ts","../src/snapshot/casing.ts","../src/snapshot/extract.ts","../src/snapshot/name.ts","../src/snapshot/render.ts","../src/diff/types.ts","../src/diff/engine.ts","../src/diff/invert.ts","../src/errors.ts","../src/diff/composite-detect.ts","../src/query/relations.ts","../src/client/wrap.ts","../src/db-errors.ts","../src/migrate/errors.ts","../src/migrate/enum-drop-gate.ts","../src/migrate/journal.ts","../src/migrate/schema.ts","../src/migrate/memory-adapter.ts","../src/migrate/introspect-types.ts","../src/migrate/introspect-pg.ts","../src/migrate/introspect-sqlite.ts","../src/migrate/introspect-mysql.ts","../src/migrate/code-migration.ts","../src/migrate/source.ts","../src/adapter.ts","../src/tokens.ts","../src/client/create.ts","../src/client/plugins.ts","../src/migrate/runner.ts","../src/migrate/tenants.ts","../src/migrate/review.ts","../src/migrate/push.ts","../src/emit/pg.ts","../src/emit/sqlite.ts","../src/emit/mysql.ts","../src/cli/generate.ts","../src/cli/check.ts","../src/cli/seed.ts","../src/seed/fake.ts","../src/dsl/columns/builders.ts","../src/dsl/view.ts","../src/dsl/self-ref.ts","../src/dsl/table-forms.ts","../src/dsl/alias.ts","../src/query/operators.ts","../src/dsl/relations.ts","../src/custom-type.ts","../src/query/schema-relations-types.ts","../src/query/errors.ts","../src/query/like.ts","../src/query/order.ts","../src/dialect-marker.ts"],"mappings":";;;;;;;;;;;UAGiB;EACf;EACA;EACA;EACA;EACA;EACA;;;;;;;;;UAUe;WACN,SAASA;;EAElB,yBAAyB;;EAEzB,eAAe,QAAQ;;EAEvB,cAAc,KAAK,KAAK,6BAA6B;;EAErD,cAAc,aAAa;;EAE3B,YAAY,gBAAgB;;EAE5B,eAAe;;EAEf,aAAa,cAAc;;;;;;;;EAQ3B,oBAAoB,aAAa,aAAa,8BAA8B;;EAE5E,aAAa,cAAc;;EAE3B,cAAc,QAAQ;;;;;;EAMtB,WAAW;;WAEF;;EAET,SAAS;;;KAIC;EAAyB,QAAQ,KAAK;;EAAiC;;;;KCqFvE;UAEK;EACf,OAAO;;iBAGa,WACpB,cAAc,gBACd,kBAAkB,gBAClB,UAAU,eACV,MAAK,cACJ;;;KCtJS,gCAAgC,mBAAmB,QAAQ;UAEtD;EACf;EACA;;EAEA;EACA,SAASC;;;;;;;;EAQT,aAAa;;;;;EAKb;;;;;;EAMA;;EAEA;;;;;;;EAOA;;;;;;EAMA,UAAU;;;;;EAKV,UAAU;;UAGK;;EAEf,gCAAgC;;EAEhC,UAAU,qBAAqB,mBAAmB,QAAQ;;EAE1D;;iBAGoB,gBAAgB;EAAQ;IAAuB,QAAQ;;;KC7CjE;;cAcC,WAAQ;;cAGR,YAAS;;;iBCkCN,gBACd,QAAQ,yBACR,SAASC,WACT;EACE,SAAS;;;;;EAKT;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;iBC/Ba,cAAc;;;;;;;;;;;;;;;;;;;iBCtBd,mBAAmB,UAAU;;;;;;;;;;;;UCP5B;EACf;EACA;;UAGe;EACf;EACA,OAAO;;UAGQ;EACf;EACA,OAAO;;UAGQ;EACf;EACA;EACA;;UAGe;EACf;EACA;EACA,QAAQ;;UAGO;EACf;EACA;EACA,QAAQ;;UAGO;EACf;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA,QAAQ;EACR,OAAO;;UAGQ;EACf;EACA;EACA,OAAO;;UAGQ;EACf;EACA;EACA,OAAO;;UAGQ;EACf;EACA;EACA,IAAI;;UAGW;EACf;EACA;EACA,IAAI;;UAGW;EACf;EACA,MAAM;;UAGS;EACf;EACA,MAAM;;;;;;;;;;UAWS;EACf;EACA;EACA;;EAEA;;;;;;;;;;UAWe;EACf;;EAEA;;EAEA;;;;;;EAMA;;;;;;;;;;;;EAYA;IAA4B;IAAe;IAAgB;;;;UAI5C;EACf;EACA;;;;;;;UAQe;EACf;EACA;EACA,QAAQ;EACR,OAAO;;UAGQ;EACf;EACA;EACA,OAAO;;UAGQ;EACf;EACA;EACA,OAAO;;;;;;UAOQ;EACf;EACA,MAAM;;;UAIS;EACf;EACA,MAAM;;;UAIS;EACf;EACA;EACA;IAAQ;;EACR;IAAM;;;UAGS;EACf;EACA;EACA,QAAQ;;UAGO;EACf;EACA;EACA,QAAQ;;;UAIO;EACf;EACA,MAAM;;;UAIS;EACf;EACA,MAAM;;;UAIS;EACf;EACA;EACA;EACA;;;;;;UAOe;EACf;EACA;EACA,QAAQ;EACR;EACA;;KAGU,SACR,eACA,cACA,YACA,cACA,YACA,aACA,eACA,cACA,WACA,YACA,gBACA,iBACA,aACA,WACA,eACA,kBACA,kBACA,WACA,YACA,kBACA,mBACA,aACA,WACA,aACA,YACA,sBACA,eACA;KAEQ,YAAY;;;;;;;UC/QP;;EAEf,SAAS;;EAET,UAAU;;UAGK;EACf,UAAU;;;;;EAKV;;iBAGc,KACd,MAAM,gBACN,MAAM,gBACN,UAAS,cACR;;UA4Rc;EACf;IAAU;IAAc;;EACxB;IAAW;IAAe;IAAc;;;;;;;;iBAQ1B,qBAAqB,MAAM,gBAAgB,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;iBCjTlE,cAAc,SAAS,YAAY;iBAoKnC,oBAAoB,SAAS;;;cCtLhC,oBAAoB;WACtB;EAET,YAAY,cAAc;;;;;;;;;;;;;cAkBf,mCAAmC;WACrC;WACA;WACA;WACA;EAET,YAAY,kBAAkB,eAAe,gBAAgB;;;;;;;;;;UCE9C;;EAEf;;EAEA;;EAEA;;;;;;;UAQe;EACf,MAAM,aAAa,aAAa,8BAA8B;IAAU,MAAM;;;;;;;;;;;;;;iBAsB1D,0BACpB,QAAQ,sBACR,mBACC,QAAQ;;;;;;;;;;;cAgDE,oCAAoC;WACtC,eAAe;EAExB,YAAY,eAAe;;;;KC9GjB,mBAAmB;;;;;;KAOnB,oBAAoB,eAAe,eAAe;;;;;;;cCwCjD,iCAAiC;EAC5C;;;;KCxCU;;UAGK;EACf,SAAS;;EAET;EACA;EACA;;EAEA;;EAEA;;;cAIW,sBAAsB;WACxB,SAAS;WACT;WACA;WACA;WACA;WACA;EAET,YAAY,cAAc,iBAAiB,MAAM,mBAAmB;;MAYhE;;;cASO,6BAA6B;WAC/B;EACT,YAAY,MAAM,mBAAmB;;;cAM1B,iCAAiC;EAC5C,YAAY,MAAM,mBAAmB;;;cAW1B,4BAA4B;EACvC,YAAY,MAAM,mBAAmB;;;cAW1B,8BAA8B;EACzC,YAAY,MAAM,mBAAmB;;;cAM1B,kCAAkC;EAC7C,YAAY,MAAM,mBAAmB;MAGxB;;;cAMF,sBAAsB;EACjC,YAAY,MAAM,mBAAmB;MAGxB;;;cAMF,wBAAwB;EACnC,YAAY,MAAM,mBAAmB;;;;;;iBAsBvB,iBAAiB,cAAc,SAAS;;;cC/I3C,uBAAuB;cAEvB,2BAA2B;EACtC,YAAY;;UAKG;EACf;EACA;EACA;;cAGW,4BAA4B;WAC9B,MAAM;EAEf,YAAY,iBAAiB,MAAM;;;;;;;cAWxB,6BAA6B;WAC/B;EAET,YAAY,YAAY;;cAUb,2BAA2B;WAC7B;WACA;WACA;EAET,YAAY,YAAY,kBAAkB;;cAQ/B,iCAAiC;WACnC;EAET,YAAY;;;;;;;cAcD,+BAA+B;WACjC;WACA;WACA;WACA;EAET,YACE,YACA,0BACA,4BACA;;;;;;;;;;;;;;;;;;;;;;;UC5Da;EACf;EACA;EACA;;;;;;iBAOc,oBAAoB,cAAc;;;;;;iBAmClC,oBACd,YACA,aACA,2BACC;;;UChEc;EACf;EACA;EACA;EACA;;UAGe;EACf;EACA,SAASC;EACT,SAAS;;iBAKW,YAAY,uBAAuB,SAASA,YAAU,QAAQ;iBAe9D,mBACpB,uBACA,SAASA,WACT,OAAO,eACN;iBAOmB,qBAAqB,uBAAuB;iBAmB5C,oBACpB,sBACA,mBACC;;;cCrEU;cACA;;iBAEG,cAAc;;iBAKd,cAAc;;;;;iBAQd,WAAW,SAASC,WAAS;iBAW7B,mBACd,SAASA,WACT;iBAuCc,aAAa,SAASA,WAAS;;;;;;;;;cC7DlC,kCAAkC;WACpC,SAASC;UAEV;UACA;UACA;UACA;EAEF,yBAAyB;EAIzB,eAAe,QAAQ;EAIvB,cAAc,KAAK,KAAK,6BAA6B;EAIrD,cAAc,aAAa;EAI3B,YAAY,gBAAgB;EAM5B,eAAe;EAIf,aAAa,cAAc;EAI3B,mBAAmB,aAAa,aAAa,8BAA8B;EAM3E,aAAa,cAAc;EAI3B,cAAc,QAAQ;EAItB,SAAS;;EAKf,wBAAwB,MAAM;;EAK9B;;;;;;;;;UClEe;EACf,MAAM,aAAa,aAAa,8BAA8B;IAAU,MAAM;;;UAG/D;;EAEf;;EAEA;;;;iBC8DoB,aACpB,QAAQ,eACR,OAAM,sBACL,QAAQ;;;;;;;;;;;;UCzDM;EACf,QAAQ;IAAgB,OAAO;;;UAGhB;EACf;;;;;;;;;;iBAoGc,iBACd,IAAI,oBACJ,OAAM,0BACL;;;;;iBAWmB,sBACpB,QAAQ,aAAa,sBAAsB,oBAC3C,OAAM,0BACL,QAAQ;;;;UClIM;EACf,MAAM,aAAa,aAAa,8BAA8B,SAAS;;UAGxD;EACf;;;;;;;;;iBA+CoB,gBACpB,IAAI,mBACJ,OAAM,yBACL,QAAQ;;;;KC7DC,cAAc;;UAGT;EACf,GAAG,IAAI,cAAc;EACrB,MAAM,IAAI,cAAc;;;;;UCCT;WACN;;WAEA,OAAO;;WAEP,SAAS,oBAAoB;;;KAI5B,8BAA8B,oCAAoC;;;;;;;;;;;;;;;;iBAuB9D,eACd,OAAO,wBACP,UAAS,0BACR;;;KCxCS;UAEK;;EAEf,kBAAkB;;;;;EAKlB,eAAe;;EAEf,mBAAmB;;EAEnB,aAAa;;EAEb;;EAEA,QAAQ,eAAe;;;;;;;;;;;;;;;;;;;EAmBvB,iDAAiD;;;;;;;;;;;;;;;;;cAkBtC,yCAAa,eAAA;;;cCvDb,YAAY,eAAe;cAC3B,YAAY,eAAe;;;;;cAM3B,WAAS,eAAA;;;iBCsCN,eAAe,SAAS,KAAK,cAAc,UACzD,MAAM,sBAAsB,SAAS,MACpC,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBC2DA,sBAAsB;;;UCnGrB;EACf,SAAS;;;;;;EAMT,eAAe;;EAEf;;EAEA;;EAEA,aAAa;;EAEb,MAAM;;;;;EAKN;;UAGe;EACf;EACA;;iBA+NoB,cAAc,MAAM,gBAAgB,QAAQ;;;;;iBAqB5C,UAAU,MAAM;EAAkB;IAAgB,QAAQ;UAc/D;;EAEf;;EAEA;;;;;;iBAkCoB,YAAY,MAAM;EAAkB;IAAgB,QAAQ;UA8BjE;EACf;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;iBAGoB,cACpB,MAAM,KAAK,8CACV,QAAQ;;iBA8BW,gBACpB,MAAM;EAAkB;IACvB,QAAQ;;;UC3ZM,8BAA8B,KAAK;;EAElD,wDAAwD;;;;;;EAMxD,aAAa,qBAAqB,mBAAmB,QAAQ;;EAE7D;;EAEA;;EAEA,YAAY,QAAQ;;UAGL;EACf;;EAEA,UAAU;EACV;;UAGe;EACf,SAAS;;EAET;;;;;;;iBAQoB,eAAe,MAAM,wBAAwB,QAAQ;;;UC/B1D;EACf;;EAEA;;;;;;;;;;;;iBAaoB,gBAAgB,uBAAuB,aAAa,QAAQ;;;UCUjE;EACf,SAAS;;EAET,QAAQ;EACR,SAAS;;EAET,UAAU;;EAEV,cAAc,YAAY,qBAAqB,QAAQ;;;;;EAKvD,mBAAmB,qBAAqB;;UAGzB;EACf;EACA;;;;;;;;iBAkEoB,WAAW,MAAM,cAAc,QAAQ;;;iBC/G7C,OAAO,SAAS;;;;;;;;;cCWnB,mCAAmC;EAC9C,YAAY;;;;;;;;;;UAkBG;EACf,OAAO;EACP,KAAK;;;;;;;;;;;;iBAaS,WAAW,SAAS,WAAW,MAAK;;;;;;;;;;;;;;;;;;;iBCjBpC,UAAU,SAAS;;;UCelB;EACf;EACA,QAAQ;EACR;EACA,YAAY;;;;;;;EAOZ;;;;;;EAMA;;;;;;;;;;;EAWA,uBAAuB,qBAAqB,iBAAiB;;EAE7D,UAAU;;;;;;;;EAQV,cAAc,YAAY,qBAAqB,QAAQ;;;;;;EAMvD,oBAAoB;IAAQ;IAAc;;;UAG3B;EACf;EACA;EACA;EACA;;iBAGoB,SAAS,MAAM,kBAAkB,QAAQ;;;UC5F9C;;EAEf;;EAEA;;EAEA;EACA;;;;;;;iBAQoB,gBAAgB;EACpC,QAAQ;EACR;IACE,QAAQ;;;UCZK;;EAEf;;;iBAIoB,UAAU,cAAc;;;;;;iBAYxB,SAAS;EAAQ;EAAa;IAAqB,QAAQ;;;KCtB5E,MAAM;;UAGM;EACf;;EAEA;;;KAIU,2BAA2B,KAAK;UAE3B;EACf;;EAEA;;EAEA,YAAY,eAAe;;EAE3B,OAAO;;UAGQ;;EAEf,QAAQ;;EAER;;EAEA,YAAY,eAAe,eAAe;;;;;;;;;;;;;iBA+R5B,SAAS,oBAAoB,SAAS,kBAAkB;;;;;;;;;;;iBAuGlD,SAAS,IAC7B,IAAI,aAAa,KACjB,QAAQ,yBACR,SAAS,kBACR,QAAQ,eAAe;;;iBCvZV,UAAU,wBAAwB,iBAAiB;;UAKlD;EACf;EACA;EACA;;iBAGc,aAAa,wBAAwB,iBAAiB;iBAItD,eAAe,wBAAwB,iBAAiB;iBAMxD,WAAW;;;;;;;iBAUX,UAAU;iBACV,OAAO,gBAAgB,aAAa;EAClD,MAAM;IACJ,cAAc,YAAY;iBAKd,YAAY;;;;;;;iBAUZ,WAAW,wBAAwB,eAAe;KAQ7D;EAAgB;;;;;;;iBAOL,QAAQ,oBAAoB,iBAAiB;iBAC7C,QAAQ,UAAU,qBAChC,+BACA,2BACA;EAAW,MAAM;IAChB,cAAc,YAAY;;iBAab,QAAQ,oBAAoB,iBAAiB;iBAC7C,QAAQ,UAAU,qBAChC,+BACA,2BACA;EAAW,MAAM;IAChB,cAAc,YAAY;iBAYb,QAAQ;iBAIR,mBAAmB;iBAMnB,QAAQ,kBAAe;iBAIvB,KAAK,kBAAa;iBAIlB,QAAQ;iBAMR,WAAW;;;;;;;cAYd,yBAAyB,cAAc;EAClD,YAAY;EAIZ,qBAAqB;;iBAMP,aAAa;iBAIb,eAAe;iBAIf,QAAQ,cAAc;iBAItB,QAAQ;iBAIR,YAAY;;;;;;;;cAaf,oBAAoB;EAC/B;EAIA,wBAAwB;;iBAMV,QAAQ;;;;;;;;;iBAcR,KAAK,gBAAgB,cAAc;iBAInC,MAAM,gBAAgB,cAAc;iBAIpC,SAAS,cAAc;;;;UCvOtB;EACf;;EAEA;EACA;;KAGU,SACV,+BACA,UAAU,eAAe,iBAAiB,eAAe,gBACzD,2DACE,UAAU,OAAO,GAAG,WAAW;UAElB;;EAEf;;UAGe,wBACf,UAAU,eAAe,wBACjB;;;;;;EAMR,eAAe,MAAM,gBAAgB,OAAO,eAAe;;;iBAI7C,UACd,sBACA,UAAU,eAAe,gBACzB,oCAEA,MAAM,OACN,SAAS,GACT,oBACA,uBACA,eAAe,MAAM,gBAAgB,OAAO,eAAe,yBAC3D,QAAQ,UACP,SAAS,OAAO,GAAG,WAAW,gBAAgB;;;;;;;;;;;;;;;;iBA4BjC,KAAK,sBAAsB,UAAU,eAAe,gBAClE,MAAM,OACN,SAAS,GACT,SAAS,cACR,SAAS,OAAO,gBAAgB,gBAAgB;;iBAKnC,OAAO,iBAAiB,SAAS;;;iBCnEjC,QAAQ,uBAAuB;;;KCoB1C,gBAAgB,eAAe;KAC/B,eAAe,gBAAgB,eAAe;KAC9C,QAAQ,eAAe,aAAa;;KAGpC,SAAS,KAAK,oBAAoB,oCAAoC;;KA2B/D,aAAa,KAAK;;KAElB,aAAa,KAAK;;KAGlB,QAAQ,KAChB,cACC,UAAU,oBAAoB,MAC1B,sBACC,cACC,sBACC;KAMP,YAAY,QAAQ,WAAW,IAAI,EAAE,WAAW,gBAAgB,mBAAkB;KAClF,cAAc,QAAQ,KAAK,YAAY,KAAK,EAAE,WAAW,gBAAgB,EAAE;;UAG/D;;;WAGN;;WAEA;;WAEA,WAAW,gBAAgB,eAAe;;;KAIzC,UAAU,8BAA8B,gBAAgB,cAAc,aAAa;;;;;;iBAU/E,KACd,MAAM,cACJ,kBAAkB,cAAc,KAAK,IAAI,0BAAyB,KAAK;iBAC3D,KACd,MAAM,cACJ,kBAAkB,cAAc,KAAK,IAAI,0BAAyB,KAAK;iBAC3D,KAAK,MAAM,cAAc,mBAAmB;;;;;iBAa5C,eAAe,UAAU,YACvC,KAAK,IACJ,aAIE,kBACH,cAAc,aAAa,KAC3B;EAAY,cAAc;IAAM,SAAS,kBAEzC,gBAAgB,cAAc,aAAa;KAmBxC,MAAM,UAAU,oBAClB,WAAW,IAAI,EAAE,WAAW,oBAAoB,KAC7C,EAAE,WAAW,eACX,IACA;;;;;;;;iBAWQ,gBACR,kBACN,UAAU,qBACJ,0CAEN,MAAM,GACN,SAAS,GACT;EACE,SAAS;EACT,WAAW,WAAW,KAAK,QAAQ,EAAE;EACrC,WAAW,MAAM,gBAAgB,OAAO,eAAe;wBAqBX,MAAM;WACzC,OAAK,UAAA,GAAA,GAAA,SAAA,MAAA,gBAAA;EACd,KAAK,GAAG,gBAAgB,GAAG,KAAK,MAAM,KAAK;;;cAOlC,gBACX,kBACA,UAAU,eACV;mBAGmB;mBACA;mBACA;mBACA;mBACA;;mBAEA;EAPnB,YACmB,MAAM,GACN,QAAQ,GACR,SAAS,GACT,aAAa,OACb,aAAa;;EAEb;IAAS,OAAO,eAAe;;;;;;;;EASlD,aAAa,kBAAkB,UAAU,eACvC,KAAK,gBAAgB,YAAY,GACjC,SAAS,MAAM,MAAM,gBAAgB,OAAO,IAC5C,OAAO,QAAQ,KACd,gBAAgB,GAAG,OAAO,KAAK,IAAI,MAAK;;EAc3C,MACE,cAAc,MAAM,gBAAgB,OAAO,eAAe,mBACzD,gBAAgB,GAAG,GAAG;EAczB,SAAS,UAAU,GAAG,GAAG,SAAS,MAAM,gBAAgB;;;;;UAUhD;;;;;;iBAsBM,kBAAkB,wBAAwB,0CACxD,MAAM,GACN;EAAW,SAAS;IACnB,gBAAgB,OAAO;;;;;;iBAWV,GAAG,GAAG,UAAU,cAAc,IAC5C,SAAS,IAAI,cAAc,IAC3B,cAAc,eAAe,QAAQ,KACrC,UAAS,WAAW,kCACnB;;;;;;;;;;;;;iBAgBa,KAAK,GACnB,QAAQ,eAAe,IACvB,cAAc,eAAe,QAAQ,KACrC,UAAS,WAAW;;;KC9UjB,UAAU,sBAAsB,WAAW,4BACzC,WAAW,UACd;;KAGQ,aACV,sBACA,UAAU,eAAe,gBACzB,oCACA,oBACE,gBAAgB;;WAET,UAAU,UAAU,OAAO,eAAe;;;;;;;;;;;iBAYrC,MACd,sBACA,UAAU,eAAe,gBACzB,oCACA,kBACA,OAAO,UAAU,OAAO,GAAG,UAAU,MAAM,IAAI,aAAa,OAAO,GAAG,SAAS;;;;KCZ5E,QAAQ,KAAK,UAAU,qBAAqB,KAAK,IAAI,UAAU,iBAAiB,KAAK,IAAI;;KAGzF,WAAW,KAAK,QAAQ,WAAW,QAAQ;;KAGpC,QAAQ,eAAe,eAAe,KAAK,WAAW,KAAK;;KAGlE,IAAI,WAAW,eAAe,KAAK,WAAW;;KAG9C,OAAO,MAAM,YAAY,sBAAsB,mBAChD,WAAW,KACX,IAAI,WAAW,QAAQ;;KAGtB,WAAW,MAAM,YAAY,sBAAsB,4BAC3C,WAAW,iBACV,OAAO,OAAO,OAAO;KAE9B,YAAY,WAAW;cA8Cf,KANH,GAAC,MAAQ,GAAC,OAAS,OAAO,OAAK;cAO5B,KAPH,GAAC,MAAQ,GAAC,OAAS,OAAO,OAAK;cAQ5B,KARH,GAAC,MAAQ,GAAC,OAAS,OAAO,OAAK;cAS5B,MATH,GAAC,MAAQ,GAAC,OAAS,OAAO,OAAK;cAU5B,KAVH,GAAC,MAAQ,GAAC,OAAS,OAAO,OAAK;cAW5B,MAXH,GAAC,MAAQ,GAAC,OAAS,OAAO,OAAK;;cAqB5B,OAPH,GAAC,MAAQ,GAAC,UAAY,YAAY,OAAO,kBAAkB,gBAAc;cAQtE,UARH,GAAC,MAAQ,GAAC,UAAY,YAAY,OAAO,kBAAkB,gBAAc;;cAUtE,QAVH,GAAC,MAAQ,GAAC,UAAY,YAAY,OAAO,kBAAkB,gBAAc;cAYtE,SAAM,SAAa,MAAM,cAAY;cAIrC,YAAS,SAAa,MAAM,cAAY;;iBAMrC,QAAQ,GAAG,MAAM,GAAG,QAAQ,WAAW,KAAK;;iBAO5C,WAAW,GAAG,MAAM,GAAG,QAAQ,WAAW,KAAK;;cAOlD,UAAW,GAAC,MAAQ,GAAC,KAAO,OAAO,IAAE,MAAQ,WAAW,OAAK;;;;;;iBAU1D,OAAO,aAAa,WAAW,0BAA0B;;iBAKzD,MAAM,aAAa,WAAW,0BAA0B;cAc3D,MAAG,WAAe,WAAW,aAAW;;cAGxC,SAAM,UAAc,wBAAsB;cAC1C,YAAS,UAAc,wBAAsB;;;;;;;;;UC3JzC,YACf,gBAAgB,kBAAkB,eAAe,kBAAkB,kBAEjE,eAAe;EAGjB;EACA,QAAQ;EACR,QAAQ;EACR,YAAY;;;;;;EAMZ;EACA;EACA;;;UAIe,iBACf,gBAAgB,kBAAkB,eAAe,kBAAkB,kBAEjE,eAAe;EAGjB;EACA,QAAQ;EACR,OAAO;;UAGQ,aACf,gBAAgB,kBAAkB,eAAe,kBAAkB,kBAEjE,eAAe;EAGjB;EACA,QAAQ;;;;;;;EAOR,UAAU;;;;;;;EAOV;;EAEA,QAAQ;;;;;;;UAQO;EACf,MAAM;EACN,IAAI;EACJ;EACA,aAAa;;;;;;;UAQE,gBACf,iBAAiB,eAAe,kBAAkB,eAAe,mBAAmB,eAElF,kBAAkB,eAAe;EAGnC;EACA,QAAQ,eAAe;EACvB,SAAS,YAAY;;;UAIN,YACf,iBAAiB,eAAe,kBAAkB,eAAe,mBAAmB,eAElF,kBAAkB,eAAe;EAGnC,MAAM;EACN,IAAI;EACJ,SAAS;;KAGC,cACR,kBAAkB,eAAe;EAC/B,OAAO,kBAAkB,eAAe;EAAiB,MAAM;EAAa,IAAI;;KAE1E,WAAW,cAAc,mBAAmB,kBAAkB;;;;;;;UAQzD,cACf,iCACA,mBAAmB,eAAe,YAAY,eAAe;EAE7D;EACA,eAAe;EACf,aAAa;;UAGL;EACR,MAAM,UAAU,kBAAkB,eAAe,iBAC/C,QAAQ,GACR;IAAQ,QAAQ;IAAa,YAAY;IAAa;QACnD,YAAY;EACjB,OAAO,UAAU,kBAAkB,eAAe,iBAChD,QAAQ,GACR;IAAS;IAAuB,UAAU;QACvC,aAAa;EAClB,YAAY,UAAU,kBAAkB,eAAe,iBACrD,QAAQ,GACR,MAAM,cACH,aAAa;EAClB,WAAW,UAAU,kBAAkB,eAAe,iBACpD,QAAQ,GACR,MAAM,cACH,iBAAiB;EACtB,UAAU,UAAU,eAAe,kBAAkB,eAAe,kBAClE,MAAM,YAAY,OACf,gBAAgB;;;;;;;;;iBAUP,UACd,UAAU,kBAAkB,eAAe,iBAC3C,UAAU,eAAe,WACzB,QAAQ,GAAG,UAAU,GAAG,YAAY,IAAI,cAAc,aAAa;;;UCtIpD,kBAAkB,KAAK;;;;;;;EAOtC;;EAEA,YAAY,OAAO,QAAQ;;EAE3B,cAAc,QAAQ,YAAY;;;;;;;;;;;cAYvB,oBAAoB,aAAa,cAAc;;WAEjD,YAAY,OAAO;;WAEnB,cAAc,oBAAoB;EAE3C,YAAY,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;iBA0BtB,WAAW,KAAK,MAAM,kBAAkB,aAAa,oBAAoB;;;;;;;;;;;;;KC/C7E,0BAA0B,KAAK,iBAEtC,WAAW,IAAI,EAAE,WAAW,oBAAoB,cAAc,KAC3D,wBACE,UAAU,eAAe;EACrB,QAAQ;EAAQ,WAAW,iBAAiB;mCAIhD;;;;;;KAQL,iBAAiB,UAAU,eAAe,gBAC5C,WAAW;EACV,MAAM,EAAE;EACR,QAAQ,EAAE,qBAAqB,gBAAgB,GAAG,eAAe,kBAC7D,mBACE;KAGH,EAAE;EAAa;;EAAsB;;;;;;;KAQvC,cAAc;EAAY;EAAgB,WAAW,eAAe;QACtE,UAAU,cAAc,QAAQ;EAAK,QAAQ;;;;;;;;cCxDnC,4CAA4C;WAC9C;WACA;EACT,YAAY,qBAAqB;;;;;;;cAgBtB,kCAAkC;WACpC;WACA;EACT,YAAY,kBAAkB;;;;;;;;cAiBnB,2CAA2C;WAC7C;WACA;EACT,YAAY,qBAAqB;;;;;;;;;;;cAoBtB,sCAAsC;WACxC;EAET,YAAY;;;;;;;cA0BD,yCAAyC;WAC3C;EACT,YAAY;;;;;;;;;cAiBD,kDAAkD;WACpD;WACA;WACA;;WAEA;EACT,YACE,qBACA,qBACA,sBACA;;;;;;;;;cAwBS,2CAA2C;WAC7C;WACA;WACA;EACT,YAAY,qBAAqB,sBAAsB;;;;;;;cAsB5C,oCAAoC;WACtC;WACA;WACA;EACT,YAAY,qBAAqB,sBAAsB,kBAAkB;;;;;;;;;;;;;;;;;;;KC1K/D;;;;;;;;;;iBAWI,WAAW,eAAe;;;;;;;;;;;;iBA4B1B,YACd,eACA,OAAM,eACN;;;;;;;;;;;iBChDc,KAAK,GAAG,YAAY,WAAW,KAAK,WAAW;;iBAK/C,IAAI,GAAG,YAAY,WAAW,KAAK,WAAW;;;;;;;;;;;;;;;;;;;;cCQjD;KAED;;iBAKI,aAAa,iBAAiB,SAAS;;iBAKvC,YAAY,kBAAkB,SAAS,GAAG,KAAK,aAAa;;;;;;;iBAgB5D,gBAAgB,kBAAkB"}
@@ -1,200 +0,0 @@
1
- /**
2
- * @forinda/kickjs-db v8.8.0
3
- *
4
- * Copyright (c) Felix Orinda
5
- *
6
- * This source code is licensed under the MIT license found in the
7
- * LICENSE file in the root directory of this source tree.
8
- *
9
- * @license MIT
10
- */
11
- import{Ct as derivedUniqueName,D as emitPg,J as withTableRenames,K as diff,N as MigrationLockError,O as MigrationDriftError,S as readJournal,St as derivedFkName,Tt as snapshotTableName,Y as extractSnapshot,_ as emitMysql,_t as buildTable,b as appendJournalEntry,bt as unwrapTable,d as migrateLatest,g as checkDrift,p as migrateStatus,q as findRenameCandidates,st as KickDbError,vt as qualifiedTableName,w as loadModule,x as computeMigrationHash,y as emitSqlite,yt as table}from"./create-K_h9SGPl.mjs";import{r as ColumnBuilder}from"./custom-type-BPJpUuWz.mjs";import{BinaryOperationNode,Kysely as Kysely$1,OperationNodeTransformer,OperatorNode,ValueNode,sql,sql as sql$1}from"kysely";import{createToken,defineAdapter}from"@forinda/kickjs";import{mkdir,readFile,readdir,writeFile}from"node:fs/promises";import{existsSync,readFileSync}from"node:fs";import path from"node:path";import{fileURLToPath,pathToFileURL}from"node:url";function renderSchemaSource(snapshot){let usedColumnHelpers=/* @__PURE__ */ new Set,tableSources=[],enums=snapshot.enums??{};for(let table of Object.values(snapshot.tables))tableSources.push(renderTable(table,usedColumnHelpers,enums));let views=Object.values(snapshot.views??{});for(let v of views)tableSources.push(renderView(v,usedColumnHelpers,enums));let helpers=[`table`,...Array.from(usedColumnHelpers).toSorted()];views.some(v=>!v.materialized)&&helpers.push(`view`);let viewIndexes=views.flatMap(v=>v.indexes??[]);viewIndexes.some(i=>!i.unique)&&!helpers.includes(`index`)&&helpers.push(`index`),viewIndexes.some(i=>i.unique)&&!helpers.includes(`unique`)&&helpers.push(`unique`),Object.values(snapshot.tables).some(t=>t.indexes.some(i=>!isAutoUniqueName(t.name,i)))&&helpers.push(`index`),Object.values(snapshot.tables).some(t=>t.indexes.some(i=>i.unique&&!isAutoUniqueName(t.name,i)))&&!helpers.includes(`unique`)&&helpers.push(`unique`);let lines=[`import { ${helpers.join(`, `)} } from '@forinda/kickjs-db'`],enumDecls=Object.values(enums),pgImports=[...enumDecls.length>0?[`pgEnum`]:[],...views.some(v=>v.materialized)?[`materializedView`]:[],...Object.values(snapshot.tables).some(t=>t.policies?.length)?[`policy`]:[]];pgImports.length>0&&lines.push(`import { ${pgImports.join(`, `)} } from '@forinda/kickjs-db/pg'`);let body=[];if(enumDecls.length>0){for(let e of enumDecls.toSorted((a,b)=>a.name.localeCompare(b.name))){let values=e.values.map(v=>`'${v.replace(/'/g,`\\'`)}'`).join(`, `);body.push(`export const ${enumIdent(e.name)} = pgEnum('${e.name}', ${values})`)}body.push(``)}return[...lines,``,...body,...tableSources].join(`
12
- `).trimEnd()+`
13
- `}function renderView(v,helpers,enums){let columns=Object.values(v.columns??{}).map(c=>` ${jsKey(c.name)}: ${renderColumn(c,helpers,void 0,!1,v.name,enums)},`),opts=[`as: ${"`"+v.definition.replace(/\\/g,`\\\\`).replace(/`/g,"\\`").replace(/\$\{/g,"\\${")+"`"}`];if(v.indexes?.length){let calls=v.indexes.map(i=>` ${jsKey(i.name)}: ${renderIndexCall(i)}`).join(`,
14
- `);opts.push(`constraints: (t) => ({\n${calls},\n })`)}let factory=v.materialized?`materializedView`:`view`;return`export const ${jsIdent(v.name)} = ${factory}(${strLit(v.name)}, {\n${columns.join(`
15
- `)}\n}, { ${opts.join(`, `)} })`}function renderPolicyCall(p){let s=`policy(${strLit(p.name)})`;return p.as!==`permissive`&&(s+=`.as('${p.as}')`),p.command!==`all`&&(s+=`.for('${p.command}')`),p.to.join()!==`public`&&(s+=`.to(${p.to.map(strLit).join(`, `)})`),p.using&&(s+=`.using(${strLit(p.using)})`),p.withCheck&&(s+=`.withCheck(${strLit(p.withCheck)})`),s}function enumIdent(enumName){return jsIdent(enumName)}function renderTable(table,helpers,enums){let ident=jsIdent(table.name),columns=[],singleColumnFks=/* @__PURE__ */ new Map;for(let f of table.foreignKeys){if(f.columns.length!==1)continue;let list=singleColumnFks.get(f.columns[0])??[];list.push(f),singleColumnFks.set(f.columns[0],list)}let inlined=/* @__PURE__ */ new Set;for(let col of Object.values(table.columns)){let candidates=singleColumnFks.get(col.name)??[],fk=candidates.length===1?candidates[0]:void 0;fk&&inlined.add(fk);let inlineUnique=table.indexes.find(i=>i.unique&&i.columns.length===1&&i.columns[0]===col.name&&isAutoUniqueName(table.name,i))!==void 0;columns.push(` ${jsKey(col.name)}: ${renderColumn(col,helpers,fk,inlineUnique,table.name,enums)},`)}let explicitIndexes=table.indexes.filter(i=>!isAutoUniqueName(table.name,i)),deferredFks=table.foreignKeys.filter(f=>!inlined.has(f)),tableArgs=[strLit(table.name),`{\n${columns.join(`
16
- `)}\n}`],callbacks=[...explicitIndexes.map(i=>` ${jsKey(i.name)}: ${renderIndexCall(i)}`),...(table.policies??[]).map(p=>` ${jsKey(p.name)}: ${renderPolicyCall(p)}`)].join(`,
17
- `),constraints=callbacks?`(t) => ({\n${callbacks},\n })`:void 0,rls=table.rls?.force?`{ force: true }`:table.rls&&!table.policies?.length?`true`:void 0;if(table.comment!==void 0||rls){let parts=[];table.comment!==void 0&&parts.push(`comment: ${strLit(table.comment)}`),rls&&parts.push(`rls: ${rls}`),constraints&&parts.push(`constraints: ${constraints}`),tableArgs.push(`{ ${parts.join(`, `)} }`)}else constraints&&tableArgs.push(constraints);let src=`export const ${ident} = table(${tableArgs.join(`, `)})`;if(deferredFks.length>0){src+=`
18
- // TODO: kick db introspect — composite foreign keys, and columns with more than one, not auto-rendered:
19
- `;for(let f of deferredFks)src+=`// ${f.name}: (${f.columns.join(`, `)}) → ${f.refTable}(${f.refColumns.join(`, `)})\n`}return src}function renderColumn(col,helpers,fk,inlineUnique,tableName,enums){if(enums[col.type])return chainSuffix(`${enumIdent(col.type)}()`,col,fk,inlineUnique,tableName);let{helperName,args,isArray}=pickColumnHelper(col);return helpers.add(helperName),chainSuffix(`${helperName}(${args})${isArray?`.array()`:``}`,col,fk,inlineUnique,tableName)}function chainSuffix(base,col,fk,inlineUnique,tableName){let chain=base;if(col.primaryKey&&(chain+=`.primaryKey()`),!col.primaryKey&&!col.nullable&&(chain+=`.notNull()`),col.default!==null&&(chain+=`.default(${JSON.stringify(col.default)})`),col.identity===`always`&&(chain+=`.generatedAlwaysAsIdentity()`),col.identity===`byDefault`&&(chain+=`.generatedByDefaultAsIdentity()`),col.generated){let virtual=col.generated.stored?``:`, { stored: false }`;chain+=`.generatedAlwaysAs(${strLit(col.generated.expression)}${virtual})`}if(inlineUnique&&(chain+=`.unique()`),col.comment!==void 0&&(chain+=`.comment(${strLit(col.comment)})`),col.colName!==void 0&&(chain+=`.colName(${strLit(col.colName)})`),fk){let ref=`${jsIdent(fk.refTable)}.${jsIdent(fk.refColumns[0])}`,opts=[];fk.onDelete!==`no_action`&&opts.push(`onDelete: '${fk.onDelete}'`),fk.onUpdate!==void 0&&fk.onUpdate!==`no_action`&&opts.push(`onUpdate: '${fk.onUpdate}'`),fk.name!==derivedFkName(tableName,col.name)&&opts.push(`name: ${strLit(fk.name)}`);let optArg=opts.length>0?`, { ${opts.join(`, `)} }`:``;chain+=`.references(() => ${ref}${optArg})`}return chain}function pickColumnHelper(col){let isArray=col.type.endsWith(`[]`),t=isArray?col.type.slice(0,-2):col.type;return t===`serial`?{helperName:`serial`,args:``,isArray}:t===`bigserial`?{helperName:`bigSerial`,args:``,isArray}:t===`smallserial`?{helperName:`serial`,args:``,isArray}:t===`integer`?{helperName:`integer`,args:``,isArray}:t===`bigint`?{helperName:`bigint`,args:``,isArray}:t===`smallint`?{helperName:`smallint`,args:``,isArray}:t===`real`?{helperName:`real`,args:``,isArray}:t===`double precision`?{helperName:`doublePrecision`,args:``,isArray}:/^numeric(\(.+\))?$/.test(t)?{helperName:`numeric`,args:extractParens(t),isArray}:/^varchar(\(\d+\))?$/.test(t)?{helperName:`varchar`,args:extractParens(t),isArray}:/^char(\(\d+\))?$/.test(t)?{helperName:`char`,args:extractParens(t),isArray}:t===`text`?{helperName:`text`,args:``,isArray}:t===`boolean`?{helperName:`boolean`,args:``,isArray}:t===`timestamp`?{helperName:`timestamp`,args:``,isArray}:t===`timestamptz`?{helperName:`timestamptz`,args:``,isArray}:t===`date`?{helperName:`date`,args:``,isArray}:t===`time`?{helperName:`time`,args:``,isArray}:t===`interval`?{helperName:`interval`,args:``,isArray}:t===`uuid`?{helperName:`uuid`,args:``,isArray}:t===`jsonb`?{helperName:`jsonb`,args:``,isArray}:t===`json`?{helperName:`json`,args:``,isArray}:t===`bytea`?{helperName:`bytea`,args:``,isArray}:{helperName:`text`,args:`/* TODO: ${t} */`,isArray}}function extractParens(t){let m=t.match(/\(([^)]+)\)/);return m?m[1]:``}function renderIndexCall(idx){let helper=idx.unique?`unique`:`index`,key=c=>c.startsWith(`(`)?strLit(c.slice(1,-1)):`t.${jsIdent(c)}`,call=`${helper}(${strLit(idx.name)}).on(${idx.columns.map(key).join(`, `)})`;idx.using&&(call+=`.using(${strLit(idx.using)})`);for(let[k,op]of Object.entries(idx.opclasses??{}))call+=`.op(${key(k)}, ${strLit(op)})`;return idx.include?.length&&(call+=`.include(${idx.include.map(c=>`t.${jsIdent(c)}`).join(`, `)})`),idx.where&&(call+=`.where(${strLit(idx.where)})`),idx.concurrently&&(call+=`.concurrently()`),call}function isAutoUniqueName(tableName,idx){return idx.unique&&idx.columns.length===1&&idx.name===derivedUniqueName(tableName,idx.columns[0])}function strLit(value){return/^[^'\\\r\n\u2028\u2029]*$/.test(value)?`'${value}'`:JSON.stringify(value)}function jsIdent(raw){return/^[A-Za-z_$][\w$]*$/.test(raw)?raw:`_${raw.replace(/[^\w$]/g,`_`)}`}function jsKey(raw){return/^[A-Za-z_$][\w$]*$/.test(raw)?raw:JSON.stringify(raw)}function invertChanges(forward){let reversed=[];for(let change of forward)change.kind!==`createSchema`&&change.kind!==`createRole`&&change.kind!==`alterRole`&&reversed.push(invert(change));let ordered=reversed.toReversed(),droppedTables=new Set(ordered.filter(c=>c.kind===`dropTable`).map(c=>snapshotTableName(c.table))),recreatedKeys=ordered.flatMap(c=>c.kind===`createTable`?c.table.foreignKeys.map(fk=>({kind:`addForeignKey`,table:snapshotTableName(c.table),fk})):[]);return[...ordered.filter(c=>c.kind===`dropForeignKey`||c.kind===`dropIndex`||c.kind===`dropCheck`||c.kind===`dropPolicy`||c.kind===`setRowLevelSecurity`?!droppedTables.has(c.table):!0),...recreatedKeys]}function invert(change){switch(change.kind){case`createTable`:return{kind:`dropTable`,table:change.table};case`dropTable`:return{kind:`createTable`,table:change.table};case`renameTable`:return{kind:`renameTable`,from:change.to,to:change.from};case`addColumn`:return{kind:`dropColumn`,table:change.table,column:change.column};case`dropColumn`:return{kind:`addColumn`,table:change.table,column:change.column};case`renameColumn`:return{kind:`renameColumn`,table:change.table,from:change.to,to:change.from};case`alterColumn`:return{kind:`alterColumn`,table:change.table,column:change.column,before:change.after,after:change.before};case`addIndex`:return{kind:`dropIndex`,table:change.table,index:change.index};case`dropIndex`:return{kind:`addIndex`,table:change.table,index:change.index};case`addForeignKey`:return{kind:`dropForeignKey`,table:change.table,fk:change.fk};case`dropForeignKey`:return{kind:`addForeignKey`,table:change.table,fk:change.fk};case`createEnum`:return{kind:`dropEnum`,enum:change.enum};case`dropEnum`:return{kind:`createEnum`,enum:change.enum};case`addEnumValue`:return change;case`alterPrimaryKey`:return{kind:`alterPrimaryKey`,table:change.table,before:change.after,after:change.before};case`addCheck`:return{kind:`dropCheck`,table:change.table,check:change.check};case`dropCheck`:return{kind:`addCheck`,table:change.table,check:change.check};case`createPolicy`:return{kind:`dropPolicy`,table:change.table,policy:change.policy};case`dropPolicy`:return{kind:`createPolicy`,table:change.table,policy:change.policy};case`setRowLevelSecurity`:return{...change,from:change.to,to:change.from};case`createView`:return{kind:`dropView`,view:change.view};case`dropView`:return{kind:`createView`,view:change.view};case`setTableComment`:return{...change,from:change.to,to:change.from};case`setColumnComment`:return{...change,column:{...change.column,comment:change.from??void 0},from:change.to,to:change.from};case`removeEnumValue`:return change}}const AMBIGUOUS_REVERSE_KINDS=/* @__PURE__ */ new Set([`dropTable`,`dropColumn`,`alterColumn`,`addEnumValue`,`removeEnumValue`]);function hasAmbiguousReverse(forward){return forward.some(c=>AMBIGUOUS_REVERSE_KINDS.has(c.kind))}async function detectCompositeReferences(runner,enumName){let{schema,name}=splitQualifiedName(enumName);return(await runner.query(`
20
- SELECT
21
- ns_comp.nspname AS composite_schema,
22
- t_comp.typname AS composite_name,
23
- a.attname AS attribute_name,
24
- ns_enum.nspname AS enum_schema,
25
- t_enum.typname AS enum_name
26
- FROM pg_type t_comp
27
- JOIN pg_namespace ns_comp ON ns_comp.oid = t_comp.typnamespace
28
- JOIN pg_class c ON c.oid = t_comp.typrelid
29
- JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum > 0 AND NOT a.attisdropped
30
- JOIN pg_type t_enum_or_arr ON t_enum_or_arr.oid = a.atttypid
31
- JOIN pg_type t_enum ON t_enum.oid = COALESCE(NULLIF(t_enum_or_arr.typelem, 0), t_enum_or_arr.oid)
32
- JOIN pg_namespace ns_enum ON ns_enum.oid = t_enum.typnamespace
33
- WHERE t_comp.typtype = 'c'
34
- AND c.relkind = 'c'
35
- AND t_enum.typtype = 'e'
36
- AND t_enum.typname = $1
37
- AND ($2::text IS NULL OR ns_enum.nspname = $2)
38
- `,[name,schema])).rows.map(r=>({composite:`${r.composite_schema}.${r.composite_name}`,attribute:r.attribute_name,enum:`${r.enum_schema}.${r.enum_name}`}))}function splitQualifiedName(qualified){let dot=qualified.indexOf(`.`);return dot===-1?{schema:null,name:qualified}:{schema:qualified.slice(0,dot),name:qualified.slice(dot+1)}}var CompositeEnumReferenceError=class extends KickDbError{refs;constructor(refs){let summary=refs.map(r=>`${r.composite}.${r.attribute} → ${r.enum}`).join(`, `);super(`composite_enum_reference`,`Cannot generate migration: the enum value(s) being removed are reachable through composite type field(s) [${summary}]. PostgreSQL's USING-cast in the rename-recreate path can't reach into composite fields, so the migration would fail at apply time. Drop or restructure the composite type(s) first, then re-run \`kick db generate\`.`),this.refs=refs}};const KICK_MIGRATIONS_TABLE=`kick_migrations`,KICK_LOCK_TABLE=`kick_migrations_lock`;function lockTableName(table){return`${table}_lock`}function pushTableName(table){return`${table}_push`}function quoteTable(dialect,name){return dialect===`mysql`?`\`${name.replaceAll("`","``")}\``:(dialect===`postgres`?name.split(`.`):[name]).map(p=>`"${p.replaceAll(`"`,`""`)}"`).join(`.`)}function bareName(name){return name.slice(name.lastIndexOf(`.`)+1)}function migrationsTableDdl(dialect,table=KICK_MIGRATIONS_TABLE){let T=quoteTable(dialect,table),idx=quoteTable(dialect,`${bareName(table)}_batch_idx`);switch(dialect){case`postgres`:return`${table.includes(`.`)?`CREATE SCHEMA IF NOT EXISTS ${quoteTable(dialect,table.slice(0,table.lastIndexOf(`.`)))};\n `:``}CREATE TABLE IF NOT EXISTS ${T} (
39
- "id" varchar(128) PRIMARY KEY,
40
- "name" text NOT NULL,
41
- "hash" text NOT NULL,
42
- "batch" integer NOT NULL,
43
- "applied_at" timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
44
- "direction" varchar(8) NOT NULL DEFAULT 'up'
45
- );
46
- CREATE INDEX IF NOT EXISTS ${idx} ON ${T} ("batch");`;case`sqlite`:return`CREATE TABLE IF NOT EXISTS ${T} (
47
- "id" text PRIMARY KEY,
48
- "name" text NOT NULL,
49
- "hash" text NOT NULL,
50
- "batch" integer NOT NULL,
51
- "applied_at" text NOT NULL DEFAULT (datetime('now')),
52
- "direction" text NOT NULL DEFAULT 'up'
53
- );
54
- CREATE INDEX IF NOT EXISTS ${idx} ON ${T} ("batch");`;case`mysql`:return`CREATE TABLE IF NOT EXISTS ${T} (
55
- \`id\` varchar(128) PRIMARY KEY,
56
- \`name\` text NOT NULL,
57
- \`hash\` text NOT NULL,
58
- \`batch\` int NOT NULL,
59
- \`applied_at\` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
60
- \`direction\` varchar(8) NOT NULL DEFAULT 'up',
61
- INDEX ${idx} (\`batch\`)
62
- );`}}function lockTableDdl(dialect,table=KICK_MIGRATIONS_TABLE){let L=quoteTable(dialect,lockTableName(table));switch(dialect){case`postgres`:return`CREATE TABLE IF NOT EXISTS ${L} (
63
- "id" smallint PRIMARY KEY,
64
- "locked_at" timestamptz,
65
- "locked_by" text
66
- );
67
- INSERT INTO ${L} ("id") VALUES (1) ON CONFLICT DO NOTHING;`;case`sqlite`:return`CREATE TABLE IF NOT EXISTS ${L} (
68
- "id" integer PRIMARY KEY,
69
- "locked_at" text,
70
- "locked_by" text
71
- );
72
- INSERT OR IGNORE INTO ${L} ("id") VALUES (1);`;case`mysql`:return`CREATE TABLE IF NOT EXISTS ${L} (
73
- \`id\` smallint PRIMARY KEY,
74
- \`locked_at\` timestamp NULL,
75
- \`locked_by\` text
76
- );
77
- INSERT IGNORE INTO ${L} (\`id\`) VALUES (1);`}}var MemoryMigrationAdapter=class{dialect=`postgres`;rows=[];locked=null;appliedSql=[];currentSchema={version:1,dialect:`postgres`,tables:{}};async ensureMigrationTables(){}async listApplied(){return[...this.rows]}async recordApplied(row){this.rows.push({...row,appliedAt:(/* @__PURE__ */ new Date()).toISOString()})}async removeApplied(id){this.rows=this.rows.filter(r=>r.id!==id)}async acquireLock(owner){return!this.locked&&(this.locked={by:owner,at:(/* @__PURE__ */ new Date()).toISOString()},!0)}async releaseLock(){this.locked=null}async applySqlInTx(sql){this.appliedSql.push(sql)}async applyMigrationInTx(sql,bookkeeping){this.appliedSql.push(sql),bookkeeping&&`record`in bookkeeping?await this.recordApplied(bookkeeping.record):bookkeeping&&await this.removeApplied(bookkeeping.remove)}async applySqlNoTx(sql){this.appliedSql.push(sql)}async introspect(){return this.currentSchema}async close(){}__setIntrospectedSchema(snap){this.currentSchema=snap}__appliedSql(){return this.appliedSql}};const DEFAULT_EXCLUDED$2=[`kick_migrations`,`kick_migrations_lock`,`kick_migrations_push`];async function introspectPg(client,opts={}){let schema=opts.schema??`public`,excluded=opts.excludeTables??DEFAULT_EXCLUDED$2,tableRows=await client.query(`SELECT table_name,
78
- obj_description(format('%I.%I', table_schema, table_name)::regclass, 'pg_class')
79
- AS comment
80
- FROM information_schema.tables
81
- WHERE table_schema = $1 AND table_type = 'BASE TABLE'
82
- ORDER BY table_name`,[schema]),tables={};for(let t of tableRows.rows)excluded.includes(t.table_name)||(tables[t.table_name]={name:t.table_name,columns:await readColumns$2(client,schema,t.table_name),indexes:await readIndexes$2(client,schema,t.table_name),foreignKeys:await readForeignKeys$2(client,schema,t.table_name),checks:[],...t.comment===null?{}:{comment:t.comment},...await readRowLevelSecurity(client,schema,t.table_name)});let enums=await readEnums(client,schema),snapshot={version:1,dialect:`postgres`,tables},views=await readViews(client,schema);return Object.keys(views).length>0&&(snapshot.views=views),Object.keys(enums).length>0&&(snapshot.enums=enums),snapshot}async function readRowLevelSecurity(client,schema,table){let flags=await client.query(`SELECT relrowsecurity AS on, relforcerowsecurity AS force FROM pg_class
83
- WHERE oid = format('%I.%I', $1::text, $2::text)::regclass`,[schema,table]),rows=await client.query(`SELECT policyname AS name, permissive, array_to_json(roles) AS roles, cmd, qual, with_check
84
- FROM pg_policies WHERE schemaname = $1 AND tablename = $2 ORDER BY policyname`,[schema,table]),out={};return flags.rows[0]?.on&&(out.rls=flags.rows[0].force?{force:!0}:{}),rows.rows.length>0&&(out.policies=rows.rows.map(r=>({name:r.name,as:r.permissive===`RESTRICTIVE`?`restrictive`:`permissive`,command:r.cmd.toLowerCase(),to:r.roles,...r.qual===null?{}:{using:r.qual},...r.with_check===null?{}:{withCheck:r.with_check}}))),out}async function readViews(client,schema){let rows=await client.query(`SELECT viewname AS name, definition, false AS materialized
85
- FROM pg_views WHERE schemaname = $1
86
- UNION ALL
87
- SELECT matviewname, definition, true FROM pg_matviews WHERE schemaname = $1
88
- ORDER BY name`,[schema]),out={};for(let r of rows.rows){let cols=await client.query(`SELECT a.attname AS name, format_type(a.atttypid, a.atttypmod) AS type,
89
- a.attnotnull AS notnull
90
- FROM pg_attribute a
91
- WHERE a.attrelid = format('%I.%I', $1::text, $2::text)::regclass
92
- AND a.attnum > 0 AND NOT a.attisdropped
93
- ORDER BY a.attnum`,[schema,r.name]),columns={};for(let c of cols.rows)columns[c.name]={name:c.name,type:viewColumnType(c.type),nullable:!c.notnull,default:null,primaryKey:!1};let v={name:r.name,definition:r.definition.trim().replace(/;$/,``),columns};if(r.materialized){v.materialized=!0;let indexes=await readIndexes$2(client,schema,r.name);indexes.length>0&&(v.indexes=indexes)}out[r.name]=v}return out}function viewColumnType(type){return type.replace(/^character varying/,`varchar`).replace(/^character\b/,`char`).replace(/^timestamp(\(\d+\))? without time zone$/,`timestamp`).replace(/^timestamp(\(\d+\))? with time zone$/,`timestamptz`).replace(/^time(\(\d+\))? without time zone$/,`time`).replace(/,(\S)/g,`, $1`)}async function readEnums(client,schema){let rows=await client.query(`SELECT t.typname AS enum_name, e.enumlabel AS enum_value
94
- FROM pg_type t
95
- JOIN pg_enum e ON e.enumtypid = t.oid
96
- JOIN pg_namespace n ON n.oid = t.typnamespace
97
- WHERE n.nspname = $1
98
- ORDER BY t.typname, e.enumsortorder`,[schema]),out={};for(let r of rows.rows){let entry=out[r.enum_name];entry?entry.values.push(r.enum_value):out[r.enum_name]={name:r.enum_name,values:[r.enum_value]}}return out}async function readColumns$2(client,schema,table){let cols=await client.query(`SELECT column_name, data_type, udt_name, is_nullable, column_default,
99
- character_maximum_length, numeric_precision, numeric_scale,
100
- pg_get_serial_sequence(format('%I.%I', table_schema, table_name), column_name)
101
- ::regclass::text AS owned_sequence,
102
- to_regclass(
103
- (regexp_match(column_default, 'nextval\\(''([^'']+)''(::regclass)?\\)'))[1]
104
- )::text AS default_sequence,
105
- is_identity, identity_generation, generation_expression,
106
- (SELECT a.attgenerated FROM pg_attribute a
107
- WHERE a.attrelid = format('%I.%I', table_schema, table_name)::regclass
108
- AND a.attname = column_name) AS attgenerated,
109
- col_description(
110
- format('%I.%I', table_schema, table_name)::regclass, ordinal_position::int
111
- ) AS comment
112
- FROM information_schema.columns
113
- WHERE table_schema = $1 AND table_name = $2
114
- ORDER BY ordinal_position`,[schema,table]),pkCols=await client.query(`SELECT k.column_name
115
- FROM information_schema.table_constraints c
116
- JOIN information_schema.key_column_usage k
117
- ON k.constraint_name = c.constraint_name
118
- AND k.table_schema = c.table_schema
119
- WHERE c.table_schema = $1 AND c.table_name = $2 AND c.constraint_type = 'PRIMARY KEY'
120
- ORDER BY k.ordinal_position`,[schema,table]),pkSet=new Set(pkCols.rows.map(r=>r.column_name)),out={};for(let r of cols.rows){let isSerial=isSerialColumn(r);out[r.column_name]={name:r.column_name,type:isSerial?serialTypeFor(r):normalizeType$2(r),nullable:r.is_nullable===`YES`,default:isSerial?null:normalizeDefault(r.column_default),primaryKey:pkSet.has(r.column_name)},r.is_identity===`YES`&&(out[r.column_name].identity=r.identity_generation===`ALWAYS`?`always`:`byDefault`),r.comment!==null&&(out[r.column_name].comment=r.comment),r.attgenerated&&r.generation_expression&&(out[r.column_name].generated={expression:r.generation_expression,stored:r.attgenerated===`s`})}return out}function isSerialColumn(r){return!r.column_default||!r.column_default.startsWith(`nextval(`)||r.owned_sequence===null||r.owned_sequence!==r.default_sequence||r.is_nullable===`YES`?!1:r.udt_name===`int2`||r.udt_name===`int4`||r.udt_name===`int8`}function serialTypeFor(r){return r.udt_name===`int8`?`bigserial`:r.udt_name===`int2`?`smallserial`:`serial`}function normalizeType$2(r){return r.data_type===`character varying`?r.character_maximum_length?`varchar(${r.character_maximum_length})`:`varchar`:r.data_type===`character`?r.character_maximum_length?`char(${r.character_maximum_length})`:`char(1)`:r.data_type===`numeric`?r.numeric_precision!==null&&r.numeric_scale!==null?`numeric(${r.numeric_precision}, ${r.numeric_scale})`:r.numeric_precision===null?`numeric`:`numeric(${r.numeric_precision})`:r.data_type===`timestamp with time zone`?`timestamptz`:r.data_type===`timestamp without time zone`?`timestamp`:r.data_type===`time without time zone`?`time`:r.data_type===`double precision`?`double precision`:r.data_type===`USER-DEFINED`?r.udt_name:r.data_type===`ARRAY`?`${dslTypeForUdt(r.udt_name.replace(/^_/,``))}[]`:r.data_type}const UDT_TO_DSL={int2:`smallint`,int4:`integer`,int8:`bigint`,float4:`real`,float8:`double precision`,bool:`boolean`,bpchar:`char`,varchar:`varchar`,timestamp:`timestamp`,timestamptz:`timestamptz`,time:`time`,date:`date`};function dslTypeForUdt(udt){return UDT_TO_DSL[udt]??udt}function normalizeDefault(raw){if(!raw)return null;let stripped=raw.replace(/::[\w" ]+(\([^)]*\))?$/,``),upper=stripped.toUpperCase();return upper===`NOW()`||upper===`CURRENT_TIMESTAMP`?`CURRENT_TIMESTAMP`:upper===`GEN_RANDOM_UUID()`?`gen_random_uuid()`:stripped.replace(/^'(.*)'$/,`$1`)}async function readIndexes$2(client,schema,table){let rows=await client.query(`SELECT i.relname AS index_name,
121
- COALESCE(a.attname, pg_get_indexdef(ix.indexrelid, k.ord::int, true)) AS key,
122
- k.attnum = 0 AS is_expression,
123
- k.ord > ix.indnkeyatts AS is_included,
124
- ix.indisunique AS is_unique,
125
- ix.indisprimary AS is_primary,
126
- am.amname AS method,
127
- pg_get_expr(ix.indpred, ix.indrelid, true) AS predicate
128
- FROM pg_class t
129
- JOIN pg_namespace n ON n.oid = t.relnamespace
130
- JOIN pg_index ix ON ix.indrelid = t.oid
131
- JOIN pg_class i ON i.oid = ix.indexrelid
132
- JOIN pg_am am ON am.oid = i.relam
133
- JOIN unnest(ix.indkey) WITH ORDINALITY AS k(attnum, ord) ON true
134
- LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum AND k.attnum <> 0
135
- WHERE n.nspname = $1 AND t.relname = $2 AND t.relkind IN ('r', 'm')
136
- ORDER BY i.relname, k.ord`,[schema,table]),byIndex=/* @__PURE__ */ new Map;for(let r of rows.rows){let entry=byIndex.get(r.index_name);entry||(entry={name:r.index_name,columns:[],unique:r.is_unique,_isPrimary:r.is_primary},r.method!==`btree`&&(entry.using=r.method),r.predicate&&(entry.where=r.predicate),byIndex.set(r.index_name,entry)),r.is_included?entry.include=[...entry.include??[],r.key]:entry.columns.push(r.is_expression?`(${r.key})`:r.key)}return[...byIndex.values()].filter(i=>!i._isPrimary).map(({_isPrimary,...rest})=>rest).toSorted((a,b)=>a.name.localeCompare(b.name))}async function readForeignKeys$2(client,schema,table){let rows=await client.query(`SELECT tc.constraint_name,
137
- kcu.column_name,
138
- ccu.table_name AS ref_table,
139
- ccu.column_name AS ref_column,
140
- rc.delete_rule,
141
- rc.update_rule
142
- FROM information_schema.table_constraints tc
143
- JOIN information_schema.key_column_usage kcu
144
- ON kcu.constraint_name = tc.constraint_name
145
- AND kcu.table_schema = tc.table_schema
146
- JOIN information_schema.referential_constraints rc
147
- ON rc.constraint_name = tc.constraint_name
148
- AND rc.constraint_schema = tc.table_schema
149
- JOIN information_schema.constraint_column_usage ccu
150
- ON ccu.constraint_name = rc.unique_constraint_name
151
- AND ccu.constraint_schema = rc.unique_constraint_schema
152
- WHERE tc.table_schema = $1
153
- AND tc.table_name = $2
154
- AND tc.constraint_type = 'FOREIGN KEY'
155
- ORDER BY tc.constraint_name, kcu.ordinal_position`,[schema,table]),byName=/* @__PURE__ */ new Map;for(let r of rows.rows){let fk=byName.get(r.constraint_name);fk||(fk={name:r.constraint_name,columns:[],refTable:r.ref_table,refColumns:[],onDelete:mapFkAction$2(r.delete_rule),onUpdate:mapFkAction$2(r.update_rule)},byName.set(r.constraint_name,fk)),fk.columns.push(r.column_name),fk.refColumns.push(r.ref_column)}return[...byName.values()].toSorted((a,b)=>a.name.localeCompare(b.name))}function mapFkAction$2(raw){switch(raw.toUpperCase()){case`CASCADE`:return`cascade`;case`RESTRICT`:return`restrict`;case`SET NULL`:return`set_null`;case`SET DEFAULT`:return`set_default`;default:return`no_action`}}const DEFAULT_EXCLUDED$1=[`kick_migrations`,`kick_migrations_lock`,`kick_migrations_push`];function*rows$1(sql,...params){return yield{sql,params}}function*introspectSteps(opts){let excluded=opts.excludeTables??DEFAULT_EXCLUDED$1,tableRows=yield*rows$1(`SELECT name FROM sqlite_master
156
- WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '\\_cf\\_%' ESCAPE '\\'
157
- ORDER BY name`),tables={};for(let{name}of tableRows)excluded.includes(name)||(tables[name]={name,columns:yield*readColumns$1(name),indexes:yield*readIndexes$1(name),foreignKeys:yield*readForeignKeys$1(name),checks:[]});let snapshot={version:1,dialect:`sqlite`,tables},viewRows=yield*rows$1(`SELECT name, sql FROM sqlite_master WHERE type = 'view' ORDER BY name`);if(viewRows.length>0){let views={};for(let v of viewRows)views[v.name]={name:v.name,definition:viewSelect(v.sql),columns:yield*readColumns$1(v.name)};snapshot.views=views}return snapshot}function introspectSqlite(db,opts={}){let walk=introspectSteps(opts),step=walk.next();for(;!step.done;)step=walk.next(db.prepare(step.value.sql).all(...step.value.params));return step.value}async function introspectSqliteAsync(query,opts={}){let walk=introspectSteps(opts),step=walk.next();for(;!step.done;)step=walk.next(await query(step.value.sql,step.value.params));return step.value}function viewSelect(statement){let i=0,s=statement,space=()=>{for(;i<s.length&&/\s/.test(s[i]);)i++},word=w=>(space(),s.slice(i,i+w.length).toUpperCase()===w&&!/\w/.test(s[i+w.length]??``)&&(i+=w.length,!0)),close={'"':`"`,"`":"`","[":`]`,"'":`'`},identifier=()=>{space();let end=close[s[i]];if(end){for(i++;i<s.length;i++)if(s[i]===end){if(s[i+1]===end&&end!==`]`)i++;else return void i++}}else for(;i<s.length&&/[\w$]/.test(s[i]);)i++};if(word(`CREATE`),word(`TEMPORARY`)||word(`TEMP`),word(`VIEW`),word(`IF`)&&(word(`NOT`),word(`EXISTS`)),identifier(),space(),s[i]===`.`&&(i++,identifier()),space(),s[i]===`(`)for(let depth=0;i<s.length;i++){let end=close[s[i]];if(end){for(i++;i<s.length;i++)if(s[i]===end){if(s[i+1]===end&&end!==`]`)i++;else break}}else if(s[i]===`(`)depth++;else if(s[i]===`)`&&--depth===0){i++;break}}return word(`AS`),s.slice(i).trim().replace(/;$/,``)}function*readColumns$1(table){let list=yield*rows$1(`PRAGMA table_xinfo(${quote(table)})`),out={},createSql;for(let r of list){out[r.name]={name:r.name,type:normalizeType$1(r.type.replace(/\s+GENERATED\s+ALWAYS\b.*$/i,``)),nullable:Number(r.notnull)===0,default:r.dflt_value,primaryKey:Number(r.pk)>0};let hidden=Number(r.hidden??0);(hidden===2||hidden===3)&&(createSql??=(yield*rows$1(`SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?`,table))[0]?.sql,out[r.name].generated={expression:generatedExpression(createSql??``,r.name),stored:hidden===3})}return out}function*readIndexes$1(table){let list=yield*rows$1(`PRAGMA index_list(${quote(table)})`),out=[];for(let idx of list){if(idx.origin!==`c`)continue;let cols=(yield*rows$1(`PRAGMA index_info(${quote(idx.name)})`)).filter(c=>c.name!==null).map(c=>c.name),entry={name:idx.name,columns:cols,unique:Number(idx.unique)===1};if(Number(idx.partial)===1){let where=(yield*rows$1(`SELECT sql FROM sqlite_master WHERE type = 'index' AND name = ?`,idx.name))[0]?.sql?.match(/\bWHERE\b([\s\S]*)$/i)?.[1].trim();where&&(entry.where=where)}out.push(entry)}return out}function*readForeignKeys$1(table){let list=yield*rows$1(`PRAGMA foreign_key_list(${quote(table)})`),byId=/* @__PURE__ */ new Map;for(let r of list){let g=byId.get(Number(r.id))??[];g.push(r),byId.set(Number(r.id),g)}let out=[];for(let[id,group]of byId){group.sort((a,b)=>Number(a.seq)-Number(b.seq));let first=group[0];out.push({name:`${table}_${group.map(g=>g.from).join(`_`)}_fk_${id}`,columns:group.map(g=>g.from),refTable:first.table,refColumns:group.map(g=>g.to),onDelete:mapFkAction$1(first.on_delete),onUpdate:mapFkAction$1(first.on_update)})}return out}function mapFkAction$1(action){switch(action.toUpperCase()){case`CASCADE`:return`cascade`;case`RESTRICT`:return`restrict`;case`SET NULL`:return`set_null`;case`SET DEFAULT`:return`set_default`;default:return`no_action`}}function normalizeType$1(declared){return declared.trim().toLowerCase()||`text`}function quote(name){return`"`+name.replace(/"/g,`""`)+`"`}function generatedExpression(createSql,column){let name=column.replace(/[.*+?^${}()|[\]\\]/g,`\\$&`),start=RegExp(`["\`\\[]?${name}["\`\\]]?\\s[^,]*?GENERATED\\s+ALWAYS\\s+AS\\s*\\(`,`i`).exec(createSql);if(!start)return``;let depth=1,from=start.index+start[0].length;for(let i=from;i<createSql.length;i++)if(createSql[i]===`(`)depth++;else if(createSql[i]===`)`&&--depth===0)return createSql.slice(from,i).trim();return``}const DEFAULT_EXCLUDED=[`kick_migrations`,`kick_migrations_lock`,`kick_migrations_push`];async function rows(db,sql,params){let[result]=await db.query(sql,params);return result}async function introspectMysql(db,opts={}){let excluded=opts.excludeTables??DEFAULT_EXCLUDED,tableRows=await rows(db,`SELECT TABLE_NAME, TABLE_COMMENT FROM information_schema.TABLES
158
- WHERE TABLE_SCHEMA = DATABASE() AND TABLE_TYPE = 'BASE TABLE'
159
- ORDER BY TABLE_NAME`,[]),tables={};for(let t of tableRows)excluded.includes(t.TABLE_NAME)||(tables[t.TABLE_NAME]={name:t.TABLE_NAME,columns:await readColumns(db,t.TABLE_NAME),indexes:await readIndexes(db,t.TABLE_NAME),foreignKeys:await readForeignKeys(db,t.TABLE_NAME),checks:[],...t.TABLE_COMMENT?{comment:t.TABLE_COMMENT}:{}});let snapshot={version:1,dialect:`mysql`,tables},viewRows=await rows(db,`SELECT TABLE_NAME, VIEW_DEFINITION FROM information_schema.VIEWS
160
- WHERE TABLE_SCHEMA = DATABASE() ORDER BY TABLE_NAME`,[]);if(viewRows.length>0){let views={};for(let v of viewRows)views[v.TABLE_NAME]={name:v.TABLE_NAME,definition:v.VIEW_DEFINITION,columns:await readColumns(db,v.TABLE_NAME)};snapshot.views=views}return snapshot}async function readColumns(db,table){let cols=await rows(db,`SELECT COLUMN_NAME, DATA_TYPE, COLUMN_TYPE, IS_NULLABLE, COLUMN_DEFAULT, COLUMN_KEY, EXTRA,
161
- COLUMN_COMMENT
162
- FROM information_schema.COLUMNS
163
- WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?
164
- ORDER BY ORDINAL_POSITION`,[table]),out={};for(let c of cols)out[c.COLUMN_NAME]={name:c.COLUMN_NAME,type:normalizeType(c),nullable:c.IS_NULLABLE===`YES`,default:c.COLUMN_DEFAULT,primaryKey:c.COLUMN_KEY===`PRI`,...c.COLUMN_COMMENT?{comment:c.COLUMN_COMMENT}:{}};return out}async function readIndexes(db,table){let stats=await rows(db,`SELECT INDEX_NAME, COLUMN_NAME, EXPRESSION, NON_UNIQUE, SEQ_IN_INDEX, INDEX_TYPE
165
- FROM information_schema.STATISTICS
166
- WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ? AND INDEX_NAME <> 'PRIMARY'
167
- ORDER BY INDEX_NAME, SEQ_IN_INDEX`,[table]),byName=/* @__PURE__ */ new Map;for(let r of stats){let e=byName.get(r.INDEX_NAME);e||(e={name:r.INDEX_NAME,columns:[],unique:r.NON_UNIQUE===0},r.INDEX_TYPE===`HASH`&&(e.using=`hash`),byName.set(r.INDEX_NAME,e)),e.columns.push(r.COLUMN_NAME??`(${r.EXPRESSION})`)}return[...byName.values()]}async function readForeignKeys(db,table){let fkRows=await rows(db,`SELECT k.CONSTRAINT_NAME, k.COLUMN_NAME,
168
- k.REFERENCED_TABLE_NAME AS REF_TABLE, k.REFERENCED_COLUMN_NAME AS REF_COLUMN,
169
- r.DELETE_RULE, r.UPDATE_RULE, k.ORDINAL_POSITION
170
- FROM information_schema.KEY_COLUMN_USAGE k
171
- JOIN information_schema.REFERENTIAL_CONSTRAINTS r
172
- ON r.CONSTRAINT_SCHEMA = k.TABLE_SCHEMA AND r.CONSTRAINT_NAME = k.CONSTRAINT_NAME
173
- WHERE k.TABLE_SCHEMA = DATABASE() AND k.TABLE_NAME = ?
174
- AND k.REFERENCED_TABLE_NAME IS NOT NULL
175
- ORDER BY k.CONSTRAINT_NAME, k.ORDINAL_POSITION`,[table]),byName=/* @__PURE__ */ new Map;for(let r of fkRows){let g=byName.get(r.CONSTRAINT_NAME)??[];g.push(r),byName.set(r.CONSTRAINT_NAME,g)}let out=[];for(let[name,group]of byName){let first=group[0];out.push({name,columns:group.map(g=>g.COLUMN_NAME),refTable:first.REF_TABLE,refColumns:group.map(g=>g.REF_COLUMN),onDelete:mapFkAction(first.DELETE_RULE),onUpdate:mapFkAction(first.UPDATE_RULE)})}return out}function mapFkAction(action){switch(action.toUpperCase()){case`CASCADE`:return`cascade`;case`RESTRICT`:return`restrict`;case`SET NULL`:return`set_null`;case`SET DEFAULT`:return`set_default`;default:return`no_action`}}function normalizeType(c){let type=(c.COLUMN_TYPE||c.DATA_TYPE).trim(),values=/^(enum|set)\s*(\(.*\))$/is.exec(type);return values?`${values[1].toLowerCase()}${values[2]}`:type.toLowerCase()||`text`}const kickDbAdapter=defineAdapter({name:`kickjs-db`,build:config=>({async beforeStart({container}){let policy=config.migrationsOnBoot??`fail-if-pending`,pending=(await migrateStatus({adapter:config.migrationAdapter,migrationsDir:config.migrationsDir})).filter(s=>s.state===`pending`);if(pending.length>0){if(policy===`fail-if-pending`)throw Error(`kickjs-db: ${pending.length} pending migration(s); run \`kick db migrate latest\` before boot`);if(policy===`apply`){let result=await migrateLatest({adapter:config.migrationAdapter,migrationsDir:config.migrationsDir,requireReviewed:config.requireReviewed,driftCheck:config.driftCheck});config.bus&&config.bus.emit(`db:migration-applied`,{applied:result.applied,batch:result.batch})}}config.token&&container.registerFactory(config.token,()=>config.migrationAdapter)},async shutdown(){await config.migrationAdapter.close()}})}),DB_PRIMARY=createToken(`kick/db/primary`),DB_REPLICA=createToken(`kick/db/replica`),DB_CLIENT=DB_PRIMARY;var SafeNullComparisonTransformer=class extends OperationNodeTransformer{transformBinaryOperation(node){let transformed=super.transformBinaryOperation(node),{operator,leftOperand,rightOperand}=transformed;if(!OperatorNode.is(operator)||!ValueNode.is(rightOperand)||rightOperand.value!==null)return transformed;let op=operator.operator;return op!==`=`&&op!==`!=`&&op!==`<>`?transformed:BinaryOperationNode.create(leftOperand,OperatorNode.create(op===`=`?`is`:`is not`),ValueNode.createImmediate(null))}},SafeNullComparisonPlugin=class{#transformer=new SafeNullComparisonTransformer;transformQuery(args){return this.#transformer.transformNode(args.node)}async transformResult(args){return args.result}};function safeNullComparison(){return new SafeNullComparisonPlugin}async function migrateTenants(opts){let{tenants,adapterFor,concurrency=1,stopOnError=!1,onTenant,...runner}=opts,queue=[...typeof tenants==`function`?await tenants():tenants],results=[],stop=!1,migrateOne=async tenant=>{let result,adapter;try{adapter=await adapterFor(tenant),result={tenant,summary:await migrateLatest({...runner,adapter})}}catch(error){result={tenant,error},stopOnError&&(stop=!0)}finally{await adapter?.close().catch(()=>{})}results.push(result),onTenant?.(result)};return await Promise.all(Array.from({length:Math.max(1,concurrency)},async()=>{for(;;){let tenant=stop?void 0:queue.shift();if(tenant===void 0)return;await migrateOne(tenant)}})),{results,failed:results.filter(r=>r.error!==void 0).map(r=>r.tenant)}}async function reviewMigration(migrationsDir,id){let dir=path.join(migrationsDir,id),metaPath=path.join(dir,`meta.json`);if(!existsSync(metaPath))throw Error(`kickjs-db: migration '${id}' not found under ${migrationsDir}`);let meta=JSON.parse(await readFile(metaPath,`utf8`)),alreadyReviewed=meta.reviewed===!0;for(let file of[`up.sql`,`down.sql`]){let p=path.join(dir,file);if(!existsSync(p))continue;let sql=await readFile(p,`utf8`),next=sql.replace(/^-- REVIEWED: false$/m,`-- REVIEWED: true`);next!==sql&&await writeFile(p,next,`utf8`)}alreadyReviewed||(meta.reviewed=!0,await writeFile(metaPath,JSON.stringify(meta,null,2)+`
176
- `,`utf8`));let journalPath=path.join(migrationsDir,`_journal.json`),journal=JSON.parse(await readFile(journalPath,`utf8`)),entry=journal.entries.find(e=>e.id===id);return entry&&(entry.hash=await computeMigrationHash(dir),await writeFile(journalPath,JSON.stringify(journal,null,2)+`
177
- `,`utf8`)),{id,alreadyReviewed}}function emitDdl(dialect,changes,from,to){switch(dialect){case`sqlite`:return emitSqlite(changes,{from,to});case`mysql`:return emitMysql(changes);case`postgres`:return emitPg(changes)}}async function generate(opts){let migrationsAbs=path.resolve(opts.cwd,opts.config.migrationsDir),{snapshot:prev,id:previousId}=await readLatestSnapshotEntry(migrationsAbs,opts.config.dialect);if(opts.empty||opts.typescript)return await writeMigration({opts,migrationsAbs,previousId,target:prev,upBody:``,downBody:``,changeCount:0,draft:!1,empty:!0,code:opts.typescript?CODE_MIGRATION_TEMPLATE:void 0});let schemaAbs=path.resolve(opts.cwd,opts.config.schemaPath),schemaModule=await loadModule(schemaAbs,{fresh:!0}),target=extractSnapshot(schemaModule,opts.config.dialect,{casing:opts.config.casing}),renames=await resolveRenames(prev,target,opts),changes=diff(prev,target,renames);if(!opts.askRenames&&opts.onPossibleRename&&warnPossibleRenames(prev,target,changes,renames,opts.onPossibleRename),changes.length===0)return{status:`no-changes`,changeCount:0};await assertNoCompositeReferences(changes,opts.detectCompositeRefs);let dialect=opts.config.dialect,concurrent=changes.filter(isConcurrentIndexChange),rest=changes.filter(c=>!concurrent.includes(c)),stages=[...rest.length>0?[{changes:rest,pending:concurrent}]:[],...concurrent.map((c,i)=>({changes:[c],pending:concurrent.slice(i+1)}))],from=prev,previous=previousId,result;for(let[n,{changes:stage,pending}]of stages.entries()){let to=snapshotAfter(target,pending);result=await writeMigration({opts:n===0?opts:withStageName(opts,n),migrationsAbs,previousId:previous,target:to,upBody:emitDdl(dialect,stage,from,to),downBody:emitDdl(dialect,invertChanges(stage),to,from),changeCount:stage.length,draft:hasAmbiguousReverse(stage),empty:!1,transaction:!isConcurrentIndexChange(stage[0])&&void 0}),from=to,previous=path.basename(result.migrationDir)}return{...result,changeCount:changes.length}}function warnPossibleRenames(prev,target,changes,{renames={}},warn){let options=to=>to.length===1?to[0]:`<${to.join(`|`)}>`,candidates=findRenameCandidates(withTableRenames(prev,target,renames.tables??{}),target);for(let c of candidates.tables)changes.some(x=>x.kind===`dropTable`&&snapshotTableName(x.table)===c.from)&&warn({what:`table ${c.from}`,flag:`--rename-table ${c.from}=${options(c.to)}`});for(let c of candidates.columns)changes.some(x=>x.kind===`dropColumn`&&x.table===c.table&&x.column.name===c.from)&&warn({what:`column ${c.table}.${c.from}`,flag:`--rename-column ${c.table}.${c.from}=${options(c.to)}`})}async function resolveRenames(prev,target,opts){let given=opts.renames??{};if(!opts.askRenames)return{renames:given};let tables={...given.tables},claimedTables=new Set(Object.values(tables)),tableCandidates=findRenameCandidates(prev,target).tables.filter(c=>!(c.from in tables)).map(c=>Object.assign(c,{to:c.to.filter(t=>!claimedTables.has(t))})).filter(c=>c.to.length>0);tableCandidates.length>0&&Object.assign(tables,(await opts.askRenames({tables:tableCandidates,columns:[]})).tables);let columns={...given.columns},claimedColumns=new Set(Object.entries(columns).map(([key,to])=>`${key.slice(0,key.lastIndexOf(`.`))}.${to}`)),renamed=withTableRenames(prev,target,tables),columnCandidates=findRenameCandidates(renamed,target).columns.filter(c=>!(`${c.table}.${c.from}`in columns)).map(c=>Object.assign(c,{to:c.to.filter(t=>!claimedColumns.has(`${c.table}.${t}`))})).filter(c=>c.to.length>0);return columnCandidates.length>0&&Object.assign(columns,(await opts.askRenames({tables:[],columns:columnCandidates})).columns),{renames:{tables,columns},explicitRenames:!0}}function isConcurrentIndexChange(c){return(c.kind===`addIndex`||c.kind===`dropIndex`)&&c.index.concurrently===!0}function snapshotAfter(target,pending){if(pending.length===0)return target;let tables=structuredClone(target.tables);for(let c of pending.toReversed()){if(c.kind!==`addIndex`&&c.kind!==`dropIndex`)continue;let t=tables[c.table],others=t.indexes.filter(i=>i.name!==c.index.name);t.indexes=c.kind===`addIndex`?others:[...others,c.index]}return{...target,tables}}function withStageName(opts,n){let at=(opts.now?.()??/* @__PURE__ */ new Date).getTime()+n*1e3;return{...opts,name:`${opts.name}_concurrently_${n}`,now:()=>new Date(at)}}const CODE_MIGRATION_TEMPLATE=`import type { MigrationDb } from '@forinda/kickjs-db'
178
-
179
- // Runs inside the migration's transaction. \`db\` is Kysely over the live
180
- // schema — untyped on purpose, since the schema keeps changing after this
181
- // migration is written.
182
- export async function up(db: MigrationDb): Promise<void> {
183
- // await db.updateTable('users').set({ status: 'active' }).where('status', 'is', null).execute()
184
- }
185
-
186
- export async function down(db: MigrationDb): Promise<void> {
187
- // Reverse up(), or throw if it can't be.
188
- }
189
- `;function generatedBanner(){return`-- Generated by @forinda/kickjs-db v${ownPackageVersion()} — review state lives in meta.json\n`}let cachedVersion=null;function ownPackageVersion(){if(cachedVersion)return cachedVersion;let here=path.dirname(fileURLToPath(import.meta.url));for(let rel of[`../package.json`,`../../package.json`])try{let pkg=JSON.parse(readFileSync(path.resolve(here,rel),`utf8`));if(pkg.name===`@forinda/kickjs-db`&&pkg.version)return cachedVersion=pkg.version,cachedVersion}catch{}return cachedVersion=`unknown`,cachedVersion}async function writeMigration(p){let id=formatId(p.opts.now?.()??/* @__PURE__ */ new Date,p.opts.name),dir=path.join(p.migrationsAbs,id);await mkdir(dir,{recursive:!0});let upSql=generatedBanner()+(p.code?`-- Written in TypeScript: migration.ts runs instead of this file.
190
- `:p.empty?`-- Empty migration — author SQL below (data migration, seed, etc).
191
- `:``)+p.upBody+(p.upBody?`
192
- `:``);await writeFile(path.join(dir,`up.sql`),upSql,`utf8`);let downHeader=generatedBanner(),downDraft=p.draft?`-- DRAFT: ambiguous reverses present (drop column / drop table / type change). Audit before applying.
193
- `:``,downHint=p.code?`-- Written in TypeScript: migration.ts runs instead of this file.
194
- `:p.empty?`-- Empty migration — author the reverse SQL here.
195
- `:``,downSql=downHeader+downDraft+downHint+p.downBody+(p.downBody?`
196
- `:``);await writeFile(path.join(dir,`down.sql`),downSql,`utf8`),await writeFile(path.join(dir,`snapshot.json`),JSON.stringify(p.target,null,2)+`
197
- `,`utf8`),p.code&&await writeFile(path.join(dir,`migration.ts`),p.code,`utf8`),await writeFile(path.join(dir,`meta.json`),JSON.stringify({id,name:p.opts.name,createdAt:(p.opts.now?.()??/* @__PURE__ */ new Date).toISOString(),reviewed:!1,dialect:p.opts.config.dialect,previousId:p.previousId,downIsDraft:p.draft,empty:p.empty,...p.transaction===!1?{transaction:!1}:{}},null,2)+`
198
- `,`utf8`);let hash=await computeMigrationHash(dir);return await appendJournalEntry(p.migrationsAbs,p.opts.config.dialect,{id,tag:p.opts.name,hash,createdAt:(p.opts.now?.()??/* @__PURE__ */ new Date).toISOString()}),{status:`created`,migrationDir:dir,changeCount:p.changeCount,empty:p.empty}}async function readLatestSnapshotEntry(migrationsDir,dialect){let empty={version:1,dialect,tables:{}};if(!existsSync(migrationsDir))return{snapshot:empty,id:null};let dirs=(await readdir(migrationsDir)).filter(e=>/^\d{8}_\d{6}_/.test(e)).toSorted();if(dirs.length===0)return{snapshot:empty,id:null};let latest=dirs[dirs.length-1],file=path.join(migrationsDir,latest,`snapshot.json`);return{snapshot:JSON.parse(await readFile(file,`utf8`)),id:latest}}async function assertNoCompositeReferences(changes,detect){if(!detect)return;let removals=changes.filter(c=>c.kind===`removeEnumValue`);if(removals.length===0)return;let allRefs=[],seen=/* @__PURE__ */ new Set;for(let r of removals){if(seen.has(r.enum))continue;seen.add(r.enum);let refs=await detect(r.enum);allRefs.push(...refs)}if(allRefs.length>0)throw new CompositeEnumReferenceError(allRefs)}function formatId(date,name){let pad=n=>n.toString().padStart(2,`0`);return`${date.getUTCFullYear().toString()+pad(date.getUTCMonth()+1)+pad(date.getUTCDate())+`_`+pad(date.getUTCHours())+pad(date.getUTCMinutes())+pad(date.getUTCSeconds())}_${name.replace(/[^a-z0-9]+/gi,`_`).toLowerCase()}`}const pushTable=adapter=>pushTableName(adapter.migrationsTable??`kick_migrations`);function isMissingTable(err){let e=err;return e?.code===`42P01`||e?.errno===1146||typeof e?.message==`string`&&/no such table/i.test(e.message)}function dataLoss(c){switch(c.kind){case`dropTable`:return`drop table ${snapshotTableName(c.table)}`;case`dropColumn`:return`drop column ${c.table}.${c.column.name}`;case`alterColumn`:return c.before.type===c.after.type?void 0:`change ${c.table}.${c.column} from ${c.before.type} to ${c.after.type}`;case`dropEnum`:return`drop enum ${c.enum.name}`;case`removeEnumValue`:return`remove ${c.removed.join(`, `)} from enum ${c.enum}`;default:return}}async function readPushed(adapter){let db=adapter.kysely?.();if(!db)throw Error(`kickjs-db: push needs a migration adapter with kysely()`);let row;try{row=await db.selectFrom(pushTable(adapter)).select(`snapshot`).where(`id`,`=`,1).executeTakeFirst()}catch(err){if(isMissingTable(err))return;throw err}return row?JSON.parse(Buffer.from(row.snapshot,`hex`).toString(`utf8`)):void 0}function recordSql(adapter,snapshot){let hex=Buffer.from(JSON.stringify(snapshot),`utf8`).toString(`hex`),text=snapshot.dialect===`mysql`?`LONGTEXT`:`TEXT`,TABLE=quoteTable(adapter.dialect,pushTable(adapter));return[`CREATE TABLE IF NOT EXISTS ${TABLE} (id INTEGER PRIMARY KEY, snapshot ${text} NOT NULL);`,`DELETE FROM ${TABLE};`,`INSERT INTO ${TABLE} (id, snapshot) VALUES (1, '${hex}');`].join(`
199
- `)}function isEmpty(s){return Object.keys(s.tables).length===0&&Object.keys(s.enums??{}).length===0&&Object.keys(s.views??{}).length===0}async function pushSchema(opts){if(process.env.NODE_ENV===`production`)throw Error(`kickjs-db: push is for prototyping — refused with NODE_ENV=production`);let{adapter}=opts;if(await adapter.ensureMigrationTables(),(await adapter.listApplied()).length>0)throw Error("kickjs-db: this database has migrations applied — change it with `kick db generate` and `kick db migrate latest`, not push");if(!await adapter.acquireLock(`push ${process.pid}`))throw new MigrationLockError(`Another process holds the migration lock.`);try{let live=await adapter.introspect(),prev=await readPushed(adapter);if(prev)try{await checkDrift(live,prev,`error`)}catch(err){throw err instanceof MigrationDriftError?Error(`kickjs-db: the database differs from what was last pushed — changed outside push, or a MySQL push that failed partway (MySQL commits each DDL statement on its own). Make the database match the schema you last pushed, or start from an empty one; push won't guess what to keep. ${err.message}`,{cause:err}):err}else if(isEmpty(live))prev={version:1,dialect:adapter.dialect,tables:{}};else throw Error(`kickjs-db: push starts from an empty database or one it pushed to — this one has tables push didn't create`);let target=extractSnapshot(opts.schema,adapter.dialect,{casing:opts.casing}),changes=diff(prev,target,await resolveRenames(prev,target,opts)).map(c=>(c.kind===`addIndex`||c.kind===`dropIndex`)&&c.index.concurrently?{...c,index:{...c.index,concurrently:!1}}:c);if(changes.length===0)return{status:`no-changes`,changeCount:0};let losses=changes.map(dataLoss).filter(l=>l!==void 0);if(losses.length>0&&!await opts.confirmDataLoss?.(losses))throw Error(`kickjs-db: push would lose data — ${losses.join(`; `)}. Confirm it (--accept-data-loss), or name renames.`);return await adapter.applySqlInTx(`${emitDdl(adapter.dialect,changes,prev,target)}\n${recordSql(adapter,target)}`),{status:`pushed`,changeCount:changes.length}}finally{await adapter.releaseLock()}}async function resolveDbConfig(opts){let abs=path.resolve(opts.configPath),mod=await import(pathToFileURL(abs).href),db=(mod.default??mod)?.db??{};return{schemaPath:db.schemaPath??`src/db/schema.ts`,migrationsDir:db.migrationsDir??`db/migrations`,seedsDir:db.seedsDir??`db/seeds`,dialect:db.dialect??`postgres`,connectionString:db.connectionString??process.env.DATABASE_URL,adapter:db.adapter,driftCheck:db.driftCheck}}async function checkMigrations(opts){let{snapshot:prev}=await readLatestSnapshotEntry(path.resolve(opts.cwd,opts.config.migrationsDir),opts.config.dialect),schemaModule=await loadModule(path.resolve(opts.cwd,opts.config.schemaPath),{fresh:!0}),unmigratedChanges=diff(prev,extractSnapshot(schemaModule,opts.config.dialect,{casing:opts.config.casing})).length,unreviewed=[],modified=[],folders=[opts.config.migrationsDir,...opts.config.migrationsDirs??[]].map(d=>path.resolve(opts.cwd,d));for(let folder of folders)if(existsSync(folder))for(let entry of(await readJournal(folder,opts.config.dialect)).entries){let dir=path.join(folder,entry.id);JSON.parse(await readFile(path.join(dir,`meta.json`),`utf8`)).reviewed===!0?await computeMigrationHash(dir)!==entry.hash&&modified.push(entry.id):unreviewed.push(entry.id)}return{unmigratedChanges,unreviewed,modified,ok:unmigratedChanges===0&&unreviewed.length===0&&modified.length===0}}const SEED_FILE=/\.(?:[cm]?[jt]s)$/;async function listSeeds(dir){return existsSync(dir)?(await readdir(dir)).filter(f=>SEED_FILE.test(f)&&!f.endsWith(`.d.ts`)&&!/\.test\.[cm]?[jt]s$/.test(f)).toSorted():[]}async function runSeeds(opts){let all=await listSeeds(opts.dir),strip=f=>f.replace(SEED_FILE,``),byBase=/* @__PURE__ */ new Map;for(let f of all)byBase.set(strip(f),[...byBase.get(strip(f))??[],f]);let clashes=[...byBase.values()].filter(files=>files.length>1);if(clashes.length>0)throw new KickDbError(`KICK_DB_SEED_DUPLICATE`,`Seeds share a name: ${clashes.map(c=>c.join(` and `)).join(`; `)} in ${opts.dir} — keep one of each`);let wanted=opts.names?.length?new Set(opts.names.map(strip)):null,files=wanted?all.filter(f=>wanted.has(strip(f))):all;if(wanted){let missing=[...wanted].filter(n=>!files.some(f=>strip(f)===n));if(missing.length>0)throw new KickDbError(`KICK_DB_SEED_NOT_FOUND`,`No seed named ${missing.join(`, `)} in ${opts.dir}`)}let ran=[];for(let file of files){let mod;try{mod=await loadModule(path.join(opts.dir,file))}catch(cause){let err=new KickDbError(`KICK_DB_SEED_FAILED`,`Seed ${file} failed to load: ${cause instanceof Error?cause.message:String(cause)}`);throw err.cause=cause,err}if(typeof mod.default!=`function`)throw new KickDbError(`KICK_DB_SEED_INVALID`,`Seed ${file} must default-export a function: export default async function seed() { … }`);try{await mod.default()}catch(cause){let err=new KickDbError(`KICK_DB_SEED_FAILED`,`Seed ${file} failed: ${cause instanceof Error?cause.message:String(cause)}`);throw err.cause=cause,err}ran.push(file)}return{ran}}function hash(text){let h=2166136261;for(let i=0;i<text.length;i++)h=Math.imul(h^text.charCodeAt(i),16777619);return h>>>0}function rng(seed){let a=seed>>>0;return()=>{a=a+1831565813>>>0;let t=a;return t=Math.imul(t^t>>>15,t|1),t^=t+Math.imul(t^t>>>7,t|61),((t^t>>>14)>>>0)/4294967296}}const pick=(random,list)=>list[Math.floor(random()*list.length)],int=(random,min,max)=>min+Math.floor(random()*(max-min+1)),WORDS=/* @__PURE__ */ `alpha.amber.atlas.beacon.birch.bright.canyon.cedar.cobalt.coral.delta.ember.falcon.fern.glacier.harbor.indigo.jade.juniper.lagoon.lantern.maple.meadow.nova.orbit.pine.prairie.quartz.raven.river.sage.sierra.summit.timber.tundra.velvet.willow.zephyr`.split(`.`),FIRST=[`Ada`,`Alan`,`Grace`,`Linus`,`Margaret`,`Dennis`,`Barbara`,`Ken`,`Radia`,`Tim`,`Katherine`,`Edsger`],LAST=[`Lovelace`,`Turing`,`Hopper`,`Torvalds`,`Hamilton`,`Ritchie`,`Liskov`,`Thompson`,`Perlman`,`Berners`,`Johnson`,`Dijkstra`],words=(random,n)=>Array.from({length:n},()=>pick(random,WORDS)).join(` `),capitalise=s=>s.charAt(0).toUpperCase()+s.slice(1);function uuidFrom(random){let hex=Array.from({length:32},()=>int(random,0,15).toString(16));hex[12]=`4`,hex[16]=`89ab`[int(random,0,3)];let h=hex.join(``);return`${h.slice(0,8)}-${h.slice(8,12)}-${h.slice(12,16)}-${h.slice(16,20)}-${h.slice(20)}`}const PEOPLE=/user|person|people|author|member|customer|contact|employee|student|account|profile/;function textFor(table,key,random,index,unique){let k=key.toLowerCase(),first=pick(random,FIRST),last=pick(random,LAST),n=unique?`${index+1}`:``;return k.includes(`email`)?`${first}.${last}${n||int(random,1,99)}@example.com`.toLowerCase():k.includes(`url`)||k.includes(`website`)?`https://example.com/${pick(random,WORDS)}${n}`:k.includes(`phone`)?`+1555${String(int(random,0,9999999)).padStart(7,`0`)}`:k===`firstname`?first+n:k===`lastname`?last+n:k===`fullname`||k.includes(`name`)&&!k.includes(`user`)&&PEOPLE.test(table.toLowerCase())?`${first} ${last}${n?` ${n}`:``}`:k.includes(`name`)&&!k.includes(`user`)?capitalise(words(random,2))+(n?` ${n}`:``):k.includes(`slug`)||k.includes(`handle`)||k.includes(`username`)?`${pick(random,WORDS)}-${pick(random,WORDS)}${n?`-${n}`:``}`:k.includes(`password`)||k.includes(`hash`)||k.includes(`token`)?Array.from({length:32},()=>int(random,0,15).toString(16)).join(``):k.includes(`title`)||k.includes(`subject`)?capitalise(words(random,3))+(n?` ${n}`:``):[`body`,`description`,`content`,`bio`,`note`,`notes`,`summary`,`message`].some(w=>k.includes(w))?`${capitalise(words(random,int(random,6,14)))}.`:words(random,2)+(n?` ${n}`:``)}const INT_RANGES={tinyint:[0,127],smallint:[0,32767],mediumint:[0,8388607],integer:[0,1e6],int:[0,1e6],bigint:[0,1e9]};function valueFor(table,key,builder,state,random,index,unique){let enumValues=builder.values;if(Array.isArray(enumValues)&&`enumName`in builder)return pick(random,enumValues);if(`toDriver`in builder||`fromDriver`in builder)return;let type=state.type.toLowerCase(),base=type.replace(/\(.*$/,``).trim(),length=Number(/\((\d+)/.exec(type)?.[1])||void 0;if(base===`enum`){let values=[...type.matchAll(/'((?:[^']|'')*)'/g)].map(m=>m[1].replace(/''/g,`'`));return values.length?pick(random,values):void 0}if(base===`uuid`)return uuidFrom(random);if([`text`,`varchar`,`char`,`citext`,`character varying`].includes(base)){let text=textFor(table,key,random,index,unique);if(!length||text.length<=length)return text;let suffix=unique?`-${index+1}`:``;return text.slice(0,Math.max(0,length-suffix.length))+suffix}if(base in INT_RANGES){let[min,max]=INT_RANGES[base],value=unique?index+1:int(random,min,max);return base===`bigint`&&state.mode===`bigint`?BigInt(value):value}if(base===`numeric`||base===`decimal`){let[precision=10,scale=2]=(/\((\d+)\s*(?:,\s*(\d+))?\)/.exec(type)??[]).slice(1).map(d=>d===void 0?void 0:Number(d)),whole=Math.min(precision-scale,6),value=(random()*10**whole).toFixed(scale);return state.mode===`number`?Number(value):value}if(base===`real`||base===`double precision`||base===`float`||base===`double`)return Math.round(random()*1e5)/100;if(base===`boolean`||base===`bool`)return random()<.5;if([`timestamp`,`timestamptz`,`datetime`].includes(base))return/* @__PURE__ */ new Date(Date.UTC(2026,0,1)-int(random,0,31536e3)*1e3);if(base===`date`)return(/* @__PURE__ */ new Date(Date.UTC(2026,0,1)-int(random,0,365)*864e5)).toISOString().slice(0,10);if(base===`time`){let pad=n=>String(n).padStart(2,`0`);return`${pad(int(random,0,23))}:${pad(int(random,0,59))}:${pad(int(random,0,59))}`}if(base===`json`||base===`jsonb`)return{}}const isAutoIncrement=state=>/serial/.test(state.type.toLowerCase())||state.identity!==void 0;function filledElsewhere(state){return state.generated||state.identity||state.managed||state.tenancy||isAutoIncrement(state)?!0:state.primaryKey?!1:state.default!==null||state.defaultFn!==void 0}function uniqueKeys(table){let keys=/* @__PURE__ */ new Set;for(let[key,builder]of Object.entries(table.__columns)){let s=builder.__state();(s.unique||s.primaryKey)&&keys.add(key)}for(let index of table.__indexes)index.unique&&index.columns.length===1&&keys.add(index.columns[0]);return keys}function compositeForeignKey(table,fks){return[table.__primaryKey?.columns??[],...table.__indexes.filter(i=>i.unique).map(i=>i.columns)].find(cols=>cols.length>1&&cols.every(c=>fks.has(c)))??[]}function foreignKeys(table){let out=/* @__PURE__ */ new Map;for(let[key,builder]of Object.entries(table.__columns)){let ref=builder.__state().references?.thunk();ref&&out.set(key,ref)}return out}function fakeRows(tableLike,options){let table=unwrapTable(tableLike);if(!table)throw Error(`kickjs-db: fakeRows() needs a table`);let name=qualifiedTableName(table),seed=options.seed??1,unique=uniqueKeys(table),fks=foreignKeys(table),keySet=compositeForeignKey(table,fks),fkKeys=[...fks.keys()].filter(k=>options.refs?.[k]?.length).toSorted((a,b)=>Number(keySet.includes(b))-Number(keySet.includes(a)));if(keySet.length>0&&keySet.every(k=>options.refs?.[k]?.length)){let capacity=keySet.reduce((n,k)=>n*options.refs[k].length,1);if(options.count>capacity)throw Error(`kickjs-db: ${name} can hold ${capacity} distinct (${keySet.join(`, `)}) — asked for ${options.count}`)}let columns=Object.entries(table.__columns).map(([key,builder])=>({key,builder,state:builder.__state(),random:rng(hash(`${seed}:${name}:${key}`))})),rows=[];for(let index=0;index<options.count;index++){let row={},rest=index;for(let{key,builder,state,random}of columns){let override=options.overrides?.[key];if(override!==void 0){row[key]=typeof override==`function`?override({index,random}):override;continue}if(fks.has(key)){let pool=options.refs?.[key];if(pool?.length){row[key]=pool[rest%pool.length],fkKeys.indexOf(key)<fkKeys.length-1&&(rest=Math.floor(rest/pool.length));continue}if(state.nullable){row[key]=null;continue}throw Error(`kickjs-db: ${name}.${key} points at ${fks.get(key).__tableName} — give it rows to point at (counts, or refs), or an override`)}if(filledElsewhere(state))continue;let value=valueFor(name,key,builder,state,random,index,unique.has(key));if(value!==void 0)row[key]=value;else if(state.nullable)row[key]=null;else throw Error(`kickjs-db: can't make up a value for ${name}.${key} (${state.type}) — give it an override`)}rows.push(row)}return rows}function insertOrder(tables,names){let order=[],seen=/* @__PURE__ */ new Set,visit=(name,path)=>{if(seen.has(name))return;if(path.includes(name))throw Error(`kickjs-db: seedFake can't order ${[...path,name].join(` → `)} — a cycle of required foreign keys`);let table=tables.get(name);for(let ref of foreignKeys(table).values())ref.__tableName!==name&&names.includes(ref.__tableName)&&visit(ref.__tableName,[...path,name]);seen.add(name),order.push(name)};for(let name of names)visit(name,[]);return order}async function seedFake(db,schema,options){let tables=/* @__PURE__ */ new Map;for(let exported of Object.values(schema)){let table=unwrapTable(exported);table&&tables.set(qualifiedTableName(table),table)}let names=Object.keys(options.counts);for(let name of names)if(!tables.has(name))throw Error(`kickjs-db: seedFake: no table '${name}' in the schema`);let client=db,inserted={};for(let name of insertOrder(tables,names)){let table=tables.get(name),refs={};for(let[key,ref]of foreignKeys(table))ref.__tableName!==name&&(refs[key]=(inserted[ref.__tableName]??await client.selectFrom(ref.__tableName).select(ref.__name).limit(1e3).execute()).map(r=>r[ref.__name]));inserted[name]=await insertRows(client,name,table,fakeRows(table,{count:options.counts[name],seed:options.seed,overrides:options.overrides?.[name],refs}))}return inserted}async function insertRows(client,name,table,rows){if(rows.length===0)return[];if(client.dialect!==`mysql`){let out=[];for(let i=0;i<rows.length;i+=200)out.push(...await client.insertInto(name).values(rows.slice(i,i+200)).returningAll().execute());return out}let keys=table.__primaryKey?.columns??Object.entries(table.__columns).filter(([,b])=>b.__state().primaryKey).map(([k])=>k),autoKey=keys.find(k=>isAutoIncrement(table.__columns[k].__state())),out=[];for(let row of rows){let result=await client.insertInto(name).values(row).executeTakeFirst(),key={...row,...autoKey?{[autoKey]:Number(result.insertId)}:{}};if(keys.length===0){out.push(key);continue}let query=client.selectFrom(name).selectAll();for(let k of keys)query=query.where(k,`=`,key[k]);out.push(await query.executeTakeFirst()??key)}return out}function brandGenerated(col){return col}function brandNotNull(col){return col}function formatNumeric(base,precision,scale){return precision===void 0?base:scale===void 0?`${base}(${precision})`:`${base}(${precision}, ${scale})`}function serial(){return brandNotNull(brandGenerated(new ColumnBuilder(`serial`,{nullable:!1})))}function bigSerial(){return brandNotNull(brandGenerated(new ColumnBuilder(`bigserial`,{nullable:!1})))}function smallSerial(){return brandNotNull(brandGenerated(new ColumnBuilder(`smallserial`,{nullable:!1})))}function integer(){return new ColumnBuilder(`integer`)}function bigint(options){return new ColumnBuilder(`bigint`,options?{mode:options.mode}:{})}function smallint(){return new ColumnBuilder(`smallint`)}function version(){let col=integer().notNull().default(0);return col.state.managed=`version`,col}function decimal(precision,scale,options){return new ColumnBuilder(formatNumeric(`decimal`,precision,scale),options?{mode:options.mode}:{})}function numeric(precision,scale,options){return new ColumnBuilder(formatNumeric(`numeric`,precision,scale),options?{mode:options.mode}:{})}function real(){return new ColumnBuilder(`real`)}function doublePrecision(){return new ColumnBuilder(`double precision`)}function varchar(length=255){return new ColumnBuilder(`varchar(${length})`)}function char(length=1){return new ColumnBuilder(`char(${length})`)}function text(){return new ColumnBuilder(`text`)}function boolean(){return new ColumnBuilder(`boolean`)}var TimestampBuilder=class extends ColumnBuilder{constructor(typeName=`timestamp`){super(typeName)}defaultNow(){return this.state.default=`CURRENT_TIMESTAMP`,brandGenerated(this)}};function timestamp(){return new TimestampBuilder(`timestamp`)}function timestamptz(){return new TimestampBuilder(`timestamptz`)}function date(){return new ColumnBuilder(`date`)}function time(){return new ColumnBuilder(`time`)}function interval(){return new ColumnBuilder(`interval`)}var UuidBuilder=class extends ColumnBuilder{constructor(){super(`uuid`)}defaultRandom(){return this.state.default=`gen_random_uuid()`,brandGenerated(this)}};function uuid(){return new UuidBuilder}function json(){return new ColumnBuilder(`json`)}function jsonb(){return new ColumnBuilder(`jsonb`)}function bytea(){return new ColumnBuilder(`bytea`)}const SCHEMA_NAME=/^[A-Za-z_][A-Za-z0-9_$]*$/;function pgSchema(name){if(typeof name!=`string`||!SCHEMA_NAME.test(name))throw Error(`pgSchema: invalid schema name ${JSON.stringify(name)}. Expected an unquoted PostgreSQL identifier matching ${SCHEMA_NAME.source}.`);let effective=name===`public`?void 0:name;return{__isPgSchema:!0,name,table(tableName,columns,options){return buildTable(tableName,columns,options,effective)}}}function isPgSchema(value){return typeof value==`object`&&!!value&&value.__isPgSchema===!0}function build(name,columns,schema,constraints,rules){let decl=schema?pgSchema(schema).table(name,columns,constraints):table(name,columns,constraints);return Object.keys(rules).length>0&&Object.defineProperty(decl,"__rules",{value:{...rules},enumerable:!1}),decl}const FIELD_RULES=Symbol.for(`@forinda/kickjs-db/field-rules`),CLASS_TABLE=Symbol.for(`@forinda/kickjs-db/class-table`);function Rule(rule){return(prototype,key)=>{let ctor=prototype.constructor;Object.hasOwn(ctor,FIELD_RULES)||(ctor[FIELD_RULES]={...ctor[FIELD_RULES]}),ctor[FIELD_RULES][key]=rule}}function tableFromClass(cls){let meta=cls;if(!Object.hasOwn(meta,CLASS_TABLE)){let instance=new cls,columns={};for(let[key,value]of Object.entries(instance))value instanceof ColumnBuilder&&(columns[key]=value);if(Object.keys(columns).length===0)throw Error(`${cls.name} has no column fields`);let rules=meta[FIELD_RULES]??{};meta[CLASS_TABLE]=build(cls.tableName,columns,cls.schema,cls.indexes,rules)}return meta[CLASS_TABLE]}function TableBase(name,columns,options={}){let decl=build(name,columns,options.schema,options.indexes,options.rules??{});class Base{static table=decl;static from(row){return Object.assign(new this,row)}}return Base}var TableDefinition=class TableDefinition{name;schema;columns;columnRules;constraints;built;constructor(name,schema,columns,columnRules,constraints,built){this.name=name,this.schema=schema,this.columns=columns,this.columnRules=columnRules,this.constraints=constraints,this.built=built}column(key,builder,rule){let resolved=typeof builder==`function`?builder(this.lazyRefs()):builder;return new TableDefinition(this.name,this.schema,{...this.columns,[key]:resolved},rule?{...this.columnRules,[key]:rule}:this.columnRules,this.constraints,this.built)}index(constraints){let previous=this.constraints,next=constraints,combined=previous?refs=>({...previous(refs),...next(refs)}):next;return new TableDefinition(this.name,this.schema,this.columns,this.columnRules,combined,this.built)}build(){let decl=build(this.name,this.columns,this.schema,this.constraints,this.columnRules);return this.built.decl=decl,decl}lazyRefs(){let built=this.built,owner=this.schema&&this.schema!==`public`?`${this.schema}.${this.name}`:this.name;return new Proxy({},{get:(_,key)=>({__tableName:owner,__name:key,get __builder(){return built.decl[key].__builder},__state:()=>built.decl[key].__state()})})}};function defineTable(name,options={}){return new TableDefinition(name,options.schema,{},{},void 0,{})}function fk(builder,target,options={}){return builder.references(target,options)}function link(column,target,options={}){column.__builder.references(target,options)}function keyName(key){return typeof key==`string`?`(${key})`:key.__name}var IndexDecl=class{__index;constructor(name,keys,unique){this.__index={name,columns:keys.map(keyName),unique}}where(predicate){return this.__index.where=predicate,this}using(method){return this.__index.using=method,this}include(...cols){return this.__index.include=cols.map(c=>c.__name),this}op(key,opclass){let name=keyName(key);if(!this.__index.columns.includes(name))throw Error(`kickjs-db: index '${this.__index.name}' has no key ${name} to give op()`);return this.__index.opclasses={...this.__index.opclasses,[name]:opclass},this}concurrently(){return this.__index.concurrently=!0,this}};function index(name){return{on(...keys){return new IndexDecl(name,keys,!1)}}}function unique(name){return{on(...keys){return new IndexDecl(name,keys,!0)}}}function primaryKey(name){return{on(...cols){return name===void 0?{kind:`primaryKey`,columns:cols.map(c=>c.__name)}:{kind:`primaryKey`,name,columns:cols.map(c=>c.__name)}}}}function check(name,expression){return{kind:`check`,name,expression}}function alias(table,name){let refs={};for(let[key,builder]of Object.entries(table.__columns))refs[key]={__tableName:name,__name:key,__builder:builder,__state:()=>builder.__state()};return refs.$from=`${qualifiedTableName(table)} as ${name}`,refs}function isExpression(value){return typeof value==`object`&&!!value&&typeof value.toOperationNode==`function`}function isColumnRef(value){return typeof value==`object`&&!!value&&typeof value.__tableName==`string`&&typeof value.__name==`string`}function isRef(operand){return isExpression(operand)||isColumnRef(operand)}function assertRef(helper,...operands){if(!operands.some(isRef))throw TypeError(`${helper}() got only values — one side must be a column (\`users.email\`) or an expression. A string is a value, not a column name: write \`.where('email', '=', x)\` to name a column.`)}function toSql(operand){return isExpression(operand)?operand:isColumnRef(operand)?sql.ref(`${operand.__tableName}.${operand.__name}`):sql.val(operand)}function binary(name,op){return(left,right)=>(assertRef(name,left,right),sql`${toSql(left)} ${sql.raw(op)} ${toSql(right)}`)}const eq=binary(`eq`,`=`),ne=binary(`ne`,`<>`),gt=binary(`gt`,`>`),gte=binary(`gte`,`>=`),lt=binary(`lt`,`<`),lte=binary(`lte`,`<=`);function likeOp(name,op){return(left,pattern)=>(assertRef(name,left,pattern),sql`${toSql(left)} ${sql.raw(op)} ${toSql(pattern)}`)}const like=likeOp(`like`,`like`),notLike=likeOp(`notLike`,`not like`),ilike=likeOp(`ilike`,`ilike`),isNull=operand=>(assertRef(`isNull`,operand),sql`${toSql(operand)} is null`),isNotNull=operand=>(assertRef(`isNotNull`,operand),sql`${toSql(operand)} is not null`);function inArray(left,values){return assertRef(`inArray`,left,...values),values.length===0?sql`1 = 0`:sql`${toSql(left)} in (${sql.join(values.map(toSql))})`}function notInArray(left,values){return assertRef(`notInArray`,left,...values),values.length===0?sql`1 = 1`:sql`${toSql(left)} not in (${sql.join(values.map(toSql))})`}const between=(left,low,high)=>(assertRef(`between`,left,low,high),sql`${toSql(left)} between ${toSql(low)} and ${toSql(high)}`);function and(...conditions){return combine(conditions,`and`,sql`1 = 1`)}function or(...conditions){return combine(conditions,`or`,sql`1 = 0`)}function combine(conditions,op,empty){let present=conditions.filter(c=>c!==void 0);return present.length===0?empty:sql`(${sql.join(present,sql.raw(` ${op} `))})`}const not=condition=>sql`not (${condition})`,exists=subquery=>sql`exists ${subquery}`,notExists=subquery=>sql`not exists ${subquery}`;function relations(source,builder){return{__isRelations:!0,__sourceTable:source.__name,__relations:builder({one:(target,opts)=>({kind:`one`,target,fields:opts.fields,references:opts.references,...opts.relationName===void 0?{}:{relationName:opts.relationName}}),many:(target,opts)=>({kind:`many`,target,...opts?.relationName===void 0?{}:{relationName:opts.relationName},...opts?.through===void 0?{}:{through:opts.through}}),morphMany:(target,opts)=>({kind:`many`,target,morph:opts}),morphOne:(target,opts)=>({kind:`one`,target,morph:opts}),morphTo:opts=>({kind:`one`,target:Object.values(opts.targets)[0],morphTo:opts})})}}function escapeLike(input,escapeChar=`\\`){if(escapeChar.length!==1||escapeChar===`%`||escapeChar===`_`)throw Error(`escapeLike: escapeChar must be a single character other than '%' or '_'`);let e=escapeChar;return input.replaceAll(e,e+e).replaceAll(`%`,e+`%`).replaceAll(`_`,e+`_`)}function likePattern(input,mode=`contains`,escapeChar=`\\`){let safe=escapeLike(input,escapeChar);switch(mode){case`contains`:return`%${safe}%`;case`startsWith`:return`${safe}%`;case`endsWith`:return`%${safe}`;case`exact`:return safe;default:throw Error(`likePattern: unsupported match mode ${String(mode)}`)}}function desc(expression){return sql`${expression} desc`}function asc(expression){return sql`${expression} asc`}export{interval as $,index as A,introspectSqlite as At,isPgSchema as B,quoteTable as Bt,notExists as C,migrateTenants as Ct,alias as D,DB_REPLICA as Dt,or as E,DB_PRIMARY as Et,TableDefinition as F,KICK_MIGRATIONS_TABLE as Ft,bigint as G,renderSchemaSource as Gt,TimestampBuilder as H,detectCompositeReferences as Ht,defineTable as I,lockTableDdl as It,char as J,boolean as K,fk as L,lockTableName as Lt,unique as M,introspectPg as Mt,Rule as N,MemoryMigrationAdapter as Nt,IndexDecl as O,kickDbAdapter as Ot,TableBase as P,KICK_LOCK_TABLE as Pt,integer as Q,link as R,migrationsTableDdl as Rt,not as S,reviewMigration as St,notLike as T,DB_CLIENT as Tt,UuidBuilder as U,hasAmbiguousReverse as Ut,pgSchema as V,CompositeEnumReferenceError as Vt,bigSerial as W,invertChanges as Wt,decimal as X,date as Y,doublePrecision as Z,isNull as _,runSeeds as _t,escapeLike as a,smallSerial as at,lte as b,pushSchema as bt,and as c,time as ct,exists as d,uuid as dt,json as et,gt as f,varchar as ft,isNotNull as g,listSeeds as gt,inArray as h,seedFake as ht,desc as i,serial as it,primaryKey as j,introspectSqliteAsync as jt,check as k,introspectMysql as kt,between as l,timestamp as lt,ilike as m,fakeRows as mt,sql$1 as n,numeric as nt,likePattern as o,smallint as ot,gte as p,version as pt,bytea as q,asc as r,real as rt,relations as s,text as st,Kysely$1 as t,jsonb as tt,eq as u,timestamptz as ut,like as v,checkMigrations as vt,notInArray as w,safeNullComparison as wt,ne as x,generate as xt,lt as y,resolveDbConfig as yt,tableFromClass as z,pushTableName as zt};
200
- //# sourceMappingURL=src-TXge_81j.mjs.map