@forinda/kickjs-db 7.3.0 → 8.0.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.
@@ -1,118 +1,9 @@
1
1
 
2
- import { h as RelationMapEntry, n as CreateDbClientOptions, r as KickDbClient } from "./types-NkfgZHEN.mjs";
2
+ import { A as TypedColumnRefs, B as TableSnapshot, I as ForeignKeySnapshot, L as IndexSnapshot, M as ColumnSnapshot, N as Dialect$1, O as NotNullBrand, P as EnumSnapshot, R as RelationSnapshot, S as ColumnRef, T as GeneratedBrand, k as TypedColumnRef, o as SchemaLike, p as TableDecl, t as ColumnRule, v as IndexDecl, x as ColumnBuilder, z as SchemaSnapshot } from "./schema-DDMkteEP.mjs";
3
+ import { h as RelationMapEntry, n as CreateDbClientOptions, r as KickDbClient } from "./types-DtvYnaXL.mjs";
3
4
  import { InjectionToken } from "@forinda/kickjs";
4
5
  import { Generated, KyselyPlugin } from "kysely";
5
6
  import { ReadonlyKysely } from "kysely/readonly";
6
- //#region src/snapshot/types.d.ts
7
- type Dialect$1 = 'postgres' | 'sqlite' | 'mysql';
8
- type FkAction = 'cascade' | 'restrict' | 'set_null' | 'set_default' | 'no_action';
9
- interface ColumnSnapshot {
10
- name: string;
11
- type: string;
12
- nullable: boolean;
13
- default: string | null;
14
- primaryKey: boolean;
15
- }
16
- interface IndexSnapshot {
17
- name: string;
18
- columns: string[];
19
- unique: boolean;
20
- }
21
- interface ForeignKeySnapshot {
22
- name: string;
23
- columns: string[];
24
- refTable: string;
25
- refColumns: string[];
26
- onDelete: FkAction;
27
- onUpdate: FkAction;
28
- }
29
- interface CheckSnapshot {
30
- name: string;
31
- expression: string;
32
- }
33
- interface TableSnapshot {
34
- /**
35
- * Bare table name, unqualified. The schema (when any) lives in
36
- * {@link TableSnapshot.schema}; the map key on `SchemaSnapshot.tables` is
37
- * the qualified form (`billing.invoices`).
38
- */
39
- name: string;
40
- /**
41
- * Named SQL schema, from `pgSchema('x').table(...)`. Absent for tables in
42
- * the connection's default search_path, which keeps pre-schema snapshots
43
- * byte-identical (and their migration hashes valid).
44
- */
45
- schema?: string;
46
- columns: Record<string, ColumnSnapshot>;
47
- indexes: IndexSnapshot[];
48
- foreignKeys: ForeignKeySnapshot[];
49
- checks: CheckSnapshot[];
50
- }
51
- /**
52
- * PostgreSQL ENUM type declaration. Currently PG-only; the field is
53
- * optional on `SchemaSnapshot` so other dialects don't have to carry
54
- * a phantom `enums: {}`.
55
- */
56
- interface EnumSnapshot {
57
- name: string;
58
- /** Allowed values, in declaration order. PG preserves the order. */
59
- values: readonly string[];
60
- }
61
- /**
62
- * Resolved relation graph attached as a sidecar on the snapshot.
63
- * Lives on `SchemaSnapshot.relations` (optional). Keyed
64
- * sourceTable → relationName → resolved entry. Consumed by the
65
- * relational-query compiler in `packages/db/src/query/`. The
66
- * migration pipeline does not read this field — relations are
67
- * query-time sugar, not DDL.
68
- *
69
- * Shaped this way (rather than re-using the runtime `RelationsDecl`)
70
- * so the snapshot stays JSON-serializable: no function thunks, no
71
- * back-references to table objects.
72
- */
73
- interface RelationSnapshot {
74
- kind: 'one' | 'many';
75
- /** Target table name. */
76
- target: string;
77
- /** Columns on the source table that participate in the join. */
78
- sourceColumns: readonly string[];
79
- /** Columns on the target table that participate in the join. */
80
- targetColumns: readonly string[];
81
- /**
82
- * Optional pairing tag from `relationName: 'foo'` on both sides of
83
- * the relation. Disambiguates multi-FK schemas. See
84
- * docs/db/spec-relation-name.md (M4.B).
85
- */
86
- relationName?: string;
87
- }
88
- interface SchemaSnapshot {
89
- version: 1;
90
- dialect: Dialect$1;
91
- /**
92
- * Keyed by QUALIFIED name — `billing.invoices` for a table declared through
93
- * `pgSchema('billing')`, the bare name otherwise. Qualifying the key is what
94
- * lets two schemas hold same-named tables without colliding, and it makes
95
- * every `table: string` field on a diff `Change` already schema-correct:
96
- * `quoteIdent` splits on `.`, rendering `"billing"."invoices"`.
97
- */
98
- tables: Record<string, TableSnapshot>;
99
- /**
100
- * Named schemas the tables in this snapshot live in, sorted. Drives
101
- * `CREATE SCHEMA IF NOT EXISTS` emission. PG-only; absent when no table
102
- * declares a schema, so existing snapshots keep their exact shape.
103
- */
104
- schemas?: readonly string[];
105
- /** ENUM types declared via `pgEnum()`. PG-only; absent on other dialects. */
106
- enums?: Record<string, EnumSnapshot>;
107
- /**
108
- * Optional relation sidecar populated when the schema includes
109
- * `relations()` declarations. Absent when no relations are
110
- * declared so M0/M1 callers see the same snapshot shape they
111
- * always did.
112
- */
113
- relations?: Record<string, Record<string, RelationSnapshot>>;
114
- }
115
- //#endregion
116
7
  //#region src/snapshot/extract.d.ts
117
8
  declare function extractSnapshot(schema: Record<string, unknown>, dialect: Dialect$1): SchemaSnapshot;
118
9
  //#endregion
@@ -262,8 +153,6 @@ interface AddEnumValue {
262
153
  * `-- KICK ENUM REMOVE` header. The runner refuses to apply such a
263
154
  * migration without `confirmEnumDrop: true` on `RunnerOptions` (or
264
155
  * `--confirm-enum-drop` from the CLI).
265
- *
266
- * Spec: docs/db/spec-enum-value-removal.md.
267
156
  */
268
157
  interface RemoveEnumValue {
269
158
  kind: 'removeEnumValue';
@@ -286,7 +175,7 @@ interface RemoveEnumValue {
286
175
  * declared on the prior snapshot, or `null` when the column has no
287
176
  * default. The emitter wraps the type swap in
288
177
  * `DROP DEFAULT` / `SET DEFAULT … ::"<enum>"` brackets only when
289
- * this is non-null. Spec: docs/db/spec-default-preservation.md.
178
+ * this is non-null.
290
179
  */
291
180
  affectedColumns: readonly {
292
181
  table: string;
@@ -334,8 +223,6 @@ declare class KickDbError extends Error {
334
223
  *
335
224
  * The operator's options: change the column's default in the schema
336
225
  * to a value that survives the removal, or drop the default entirely.
337
- *
338
- * Spec: docs/db/spec-default-preservation.md.
339
226
  */
340
227
  declare class RemovedValueAsDefaultError extends KickDbError {
341
228
  readonly enum: string;
@@ -424,8 +311,7 @@ declare class UnreviewedMigrationError extends MigrationError {
424
311
  /**
425
312
  * Thrown by the runner when a migration carries the `-- KICK ENUM
426
313
  * REMOVE` header and the operator hasn't passed `confirmEnumDrop:
427
- * true` (CLI: `--confirm-enum-drop`). Spec:
428
- * docs/db/spec-enum-value-removal.md §4.
314
+ * true` (CLI: `--confirm-enum-drop`).
429
315
  */
430
316
  declare class MigrationEnumDropError extends MigrationError {
431
317
  readonly id: string;
@@ -445,7 +331,11 @@ declare class MigrationEnumDropError extends MigrationError {
445
331
  * `MigrationEnumDropError` when the header is present and
446
332
  * `confirmEnumDrop` is falsy.
447
333
  *
448
- * Spec: docs/db/spec-enum-value-removal.md §4.
334
+ * Why a gate: PostgreSQL has no `ALTER TYPE … DROP VALUE`, so removing
335
+ * a value means renaming and recreating the type and casting every
336
+ * column with `USING`. That cast fails on any row still holding the
337
+ * removed value, so the operator should review the migration before it
338
+ * runs rather than find out mid-deploy.
449
339
  */
450
340
  /**
451
341
  * Parsed payload from the header block. Empty arrays for keys not
@@ -694,203 +584,6 @@ declare const DB_REPLICA: InjectionToken<KickDbClient>;
694
584
  */
695
585
  declare const DB_CLIENT: InjectionToken<KickDbClient<unknown>>;
696
586
  //#endregion
697
- //#region src/dsl/columns/types.d.ts
698
- /**
699
- * Runtime + type representation of a column reference (e.g. `users.id`).
700
- * Carries the parent table name, the column's own name, plus runtime
701
- * accessors used by FK thunks and constraint builders.
702
- *
703
- * Exported so adopters can annotate self-referencing thunks without
704
- * spelling the shape inline:
705
- *
706
- * parentId: uuid().references((): ColumnRef => categories.id)
707
- *
708
- * Without the annotation the initializer of a self-referencing const
709
- * trips TS7022 — TS needs to infer the const while the initializer
710
- * already references it.
711
- */
712
- interface ColumnRef {
713
- __tableName: string;
714
- __name: string;
715
- __builder: ColumnBuilder;
716
- __state: () => ReturnType<ColumnBuilder['__state']>;
717
- }
718
- /**
719
- * Resolved FK spec — `table` / `column` are pulled by invoking `thunk()`
720
- * lazily. The thunk pattern lets self-referencing tables work:
721
- *
722
- * const categories = table('categories', {
723
- * id: uuid().primaryKey().defaultRandom(),
724
- * parentId: uuid().references((): ColumnRef => categories.id),
725
- * })
726
- *
727
- * If we resolved at `.references()` call time, `categories` would TDZ-fail
728
- * inside its own initializer. Storing the thunk and resolving on read
729
- * (extract / render / emit) defers until after the const binding lands.
730
- */
731
- interface FkSpec {
732
- thunk: () => ColumnRef;
733
- onDelete: FkAction;
734
- onUpdate: FkAction;
735
- /**
736
- * The constraint's name in the database.
737
- *
738
- * Omitted for schemas written by hand — the name is then derived as
739
- * `<table>_<column>_fk`. It is set when the schema was generated by
740
- * `kick db introspect`, because a database names its constraints itself:
741
- * Postgres' own default is `<table>_<column>_fkey`, and a DBA may have
742
- * chosen anything. Dropping the real name would make the next diff want to
743
- * rename every foreign key in the schema.
744
- */
745
- name?: string;
746
- }
747
- interface ColumnState {
748
- type: string;
749
- nullable: boolean;
750
- default: string | null;
751
- primaryKey: boolean;
752
- unique: boolean;
753
- references: FkSpec | null;
754
- }
755
- /**
756
- * Type-only brand attached to a column when it's auto-assigned by the
757
- * database (serial / bigserial / smallserial), has a runtime default
758
- * (`.default(...)`), or carries an expression default
759
- * (`uuid().defaultRandom()`, `timestamp().defaultNow()`). `SchemaToTypes<S>`
760
- * reads this marker and wraps the column type in Kysely's `Generated<T>` so
761
- * adopters can omit the column on insert.
762
- *
763
- * Runtime is a no-op — the symbol never reaches a value.
764
- */
765
- declare const KICK_GENERATED: unique symbol;
766
- type GeneratedBrand = {
767
- readonly [KICK_GENERATED]?: true;
768
- };
769
- /**
770
- * Type-only brand attached to a column when `.notNull()` or `.primaryKey()`
771
- * is called. `SchemaToTypes<S>` reads this brand to decide whether the
772
- * column type is `T` (NOT NULL) or `T | null` (default nullable).
773
- *
774
- * Why a brand instead of a class generic: chained methods (notNull,
775
- * primaryKey) can return `this & NotNullBrand` to narrow nullability while
776
- * preserving the subclass identity — so `uuid().primaryKey().defaultRandom()`
777
- * still resolves `defaultRandom()` on `UuidBuilder`. A class generic
778
- * `<TNullable>` would collapse the subclass back to the parent.
779
- */
780
- declare const KICK_NOT_NULL: unique symbol;
781
- type NotNullBrand = {
782
- readonly [KICK_NOT_NULL]?: true;
783
- };
784
- /**
785
- * Re-attach the nullability / generated brands after a transform that
786
- * must return a *new* builder type (e.g. `.array()` widening `T` to
787
- * `T[]`). Without this, `integer().notNull().array()` silently dropped
788
- * `NotNullBrand` and the row type regressed to `number[] | null`.
789
- *
790
- * Uses the same `extends` checks as `SchemaToTypes` (client/schema-types.ts)
791
- * so detection stays consistent in both directions.
792
- */
793
- type PreserveBrands<Self, Out> = Out & (Self extends NotNullBrand ? NotNullBrand : unknown) & (Self extends GeneratedBrand ? GeneratedBrand : unknown);
794
- /**
795
- * Phantom-typed column builder. The `T` generic carries the column's TS
796
- * value type (number / string / Date / etc.); nullability is tracked via
797
- * the `NotNullBrand` intersection rather than a class generic so chain
798
- * methods preserve subclass identity.
799
- *
800
- * Both `T` and the brand are erased at runtime; they exist purely so
801
- * `SchemaToTypes<S>` can pull them out per column.
802
- */
803
- declare class ColumnBuilder<T = unknown> {
804
- readonly __t?: T;
805
- protected state: ColumnState;
806
- constructor(type: string, defaults?: Partial<ColumnState>);
807
- notNull(): this & NotNullBrand;
808
- primaryKey(): this & NotNullBrand;
809
- unique(): this;
810
- array(): PreserveBrands<this, ColumnBuilder<T[]>>;
811
- references(target: () => ColumnRef, opts?: {
812
- onDelete?: FkAction;
813
- onUpdate?: FkAction;
814
- name?: string;
815
- }): this;
816
- /**
817
- * Mark the column as having a runtime / DB-assigned default. The
818
- * `GeneratedBrand` flows into `SchemaToTypes<S>` so the column wraps
819
- * in `Generated<T>` — adopters can `INSERT` without specifying it.
820
- *
821
- * Accepts the natural literal for the column type — `boolean().default(false)`,
822
- * `integer().default(0)`, `varchar().default('active')`. Non-string
823
- * literals are normalised to their SQL-literal text so the snapshot
824
- * (`ColumnSnapshot.default: string | null`) and migration emitter stay
825
- * string-only. For a quoted string default the text is the value
826
- * itself (`'active'`); booleans/numbers emit bare (`false`, `0`).
827
- */
828
- default(value: string | number | boolean): this & GeneratedBrand;
829
- toJSON(name: string): ColumnSnapshot;
830
- __state(): Readonly<ColumnState>;
831
- }
832
- //#endregion
833
- //#region src/dsl/constraints.d.ts
834
- interface IndexDecl {
835
- name: string;
836
- columns: string[];
837
- unique: boolean;
838
- }
839
- interface ColRef {
840
- __name: string;
841
- }
842
- declare function index(name: string): {
843
- on(...cols: ColRef[]): IndexDecl;
844
- };
845
- declare function unique(name: string): {
846
- on(...cols: ColRef[]): IndexDecl;
847
- };
848
- //#endregion
849
- //#region src/dsl/table.d.ts
850
- interface TableDecl<TName extends string = string, C extends Record<string, ColumnBuilder> = Record<string, ColumnBuilder>, TSchema extends string | undefined = string | undefined> {
851
- __isTable: true;
852
- __name: TName;
853
- __columns: C;
854
- __indexes: IndexDecl[];
855
- /**
856
- * Named SQL schema this table lives in, from `pgSchema('x').table(...)`.
857
- * `undefined` means the connection's default search_path (`public` on PG),
858
- * which is every table declared through the bare `table()` factory.
859
- *
860
- * PostgreSQL only — `assertSchemasSupported()` rejects a declared schema
861
- * on MySQL/SQLite at snapshot time rather than emitting subtly wrong DDL.
862
- */
863
- __schema?: TSchema;
864
- }
865
- /**
866
- * Fully-qualified name used as the snapshot key, the Kysely table key, and
867
- * the emitted identifier. `quoteIdent` splits on `.`, so `billing.invoices`
868
- * renders as `"billing"."invoices"` with no further work.
869
- *
870
- * Unqualified tables keep their bare name, so every pre-schema snapshot,
871
- * migration hash, and `KickDbSchema` key is byte-identical to before.
872
- */
873
- type QualifiedName<TName extends string, TSchema extends string | undefined> = TSchema extends string ? `${TSchema}.${TName}` : TName;
874
- /** Runtime counterpart of {@link QualifiedName}. */
875
- declare function qualifiedTableName(decl: {
876
- __name: string;
877
- __schema?: string | undefined;
878
- }): string;
879
- type TableRefs<TName extends string, C extends Record<string, ColumnBuilder>, TSchema extends string | undefined = undefined> = TableDecl<TName, C, TSchema> & { [K in keyof C]: ColumnRef; };
880
- type ConstraintBuilder<C extends Record<string, ColumnBuilder>> = (refs: { [K in keyof C]: ColumnRef; }) => Record<string, IndexDecl>;
881
- /**
882
- * Declare a typed table. The `TName extends string` generic narrows to the
883
- * literal table name so `SchemaToTypes<S>` can index by it without losing
884
- * the constant — `table('users', …)` widens to `TableDecl<'users', …>`,
885
- * not `TableDecl<string, …>`.
886
- */
887
- declare function table<TName extends string, C extends Record<string, ColumnBuilder>>(name: TName, columns: C, constraints?: ConstraintBuilder<C>): TableRefs<TName, C>;
888
- /**
889
- * Shared table constructor. `table()` passes `schema: undefined`;
890
- * `pgSchema('x').table()` passes the schema name through.
891
- */
892
- declare function buildTable<TName extends string, C extends Record<string, ColumnBuilder>, TSchema extends string | undefined>(name: TName, columns: C, constraints: ConstraintBuilder<C> | undefined, schema: TSchema): TableRefs<TName, C, TSchema>;
893
- //#endregion
894
587
  //#region src/client/schema-types.d.ts
895
588
  /**
896
589
  * Pull each column's TS type and nullability into the row shape Kysely
@@ -926,9 +619,15 @@ type TableKey<T> = T extends {
926
619
  } ? Extract<T extends {
927
620
  __schema?: infer S;
928
621
  } ? S : never, string> extends (infer Schema) ? [Schema] extends [never] ? N : Schema extends string ? `${Schema}.${N}` : N : never : never;
929
- type SchemaToTypes<S> = { [K in keyof S as S[K] extends {
622
+ /** A schema-barrel export's table: itself, or a class form's `static table`. */
623
+ type TableOf<V> = V extends {
930
624
  __isTable: true;
931
- } ? TableKey<S[K]> : never]: S[K] extends TableDecl<string, infer C, string | undefined> ? { [Col in keyof C]: ColumnTSType<C[Col]>; } : never; };
625
+ } ? V : V extends (abstract new (...args: never) => unknown) & {
626
+ table: infer T extends {
627
+ __isTable: true;
628
+ };
629
+ } ? T : never;
630
+ type SchemaToTypes<S> = { [K in keyof S as [TableOf<S[K]>] extends [never] ? never : TableKey<TableOf<S[K]>>]: TableOf<S[K]> extends TableDecl<string, infer C, string | undefined> ? { [Col in keyof C]: ColumnTSType<C[Col]>; } : never; };
932
631
  //#endregion
933
632
  //#region src/client/create.d.ts
934
633
  declare function createDbClient<TSchema, DB = SchemaToTypes<TSchema>>(opts: CreateDbClientOptions<TSchema, DB>): KickDbClient<DB>;
@@ -988,7 +687,6 @@ interface RunnerOptions {
988
687
  /**
989
688
  * Allow migrations carrying the `-- KICK ENUM REMOVE` header to
990
689
  * apply. Default `false`. CLI exposes via `--confirm-enum-drop`.
991
- * Spec: docs/db/spec-enum-value-removal.md.
992
690
  */
993
691
  confirmEnumDrop?: boolean;
994
692
  }
@@ -1212,6 +910,123 @@ declare function json<T = unknown>(): ColumnBuilder<T>;
1212
910
  declare function jsonb<T = unknown>(): ColumnBuilder<T>;
1213
911
  declare function bytea(): ColumnBuilder<Uint8Array>;
1214
912
  //#endregion
913
+ //#region src/dsl/self-ref.d.ts
914
+ declare function selfRef(column: string): () => ColumnRef;
915
+ //#endregion
916
+ //#region src/dsl/table-forms.d.ts
917
+ type ColumnsRecord = Record<string, ColumnBuilder>;
918
+ type Constraints = (refs: never) => Record<string, IndexDecl>;
919
+ type Rules = Record<string, ColumnRule | SchemaLike>;
920
+ /** The Postgres schema of a table: `undefined` for none or `public`. */
921
+ type SchemaOf<S> = S extends string ? (S extends 'public' ? undefined : `${S}`) : undefined;
922
+ /** Rules for a string column. */
923
+ type StringRule = Pick<ColumnRule, 'format' | 'minLength' | 'maxLength' | 'pattern'>;
924
+ /** Rules for a numeric column. */
925
+ type NumberRule = Pick<ColumnRule, 'minimum' | 'maximum'>;
926
+ /** The rules a column of this builder may take — a string rule on a number column fails to compile. */
927
+ type RuleFor<B> = SchemaLike | (B extends ColumnBuilder<infer T> ? [T] extends [string] ? StringRule : [T] extends [number] ? NumberRule : never : never);
928
+ type BuilderKeys<I> = { [K in keyof I]: I[K] extends ColumnBuilder ? K : never; }[keyof I];
929
+ type BuilderFields<I> = { [K in BuilderKeys<I>]: I[K] extends ColumnBuilder ? I[K] : never; };
930
+ /** A class whose fields are column builders — the input to {@link tableFromClass}. */
931
+ interface TableClass {
932
+ new (): object;
933
+ /** The table's name. */
934
+ readonly tableName: string;
935
+ /** Postgres schema the table lives in — `pgSchema(schema).table(...)`. */
936
+ readonly schema?: string;
937
+ /** Indexes / unique constraints, over {@link ClassRefs} of the class. */
938
+ readonly indexes?: (refs: never) => Record<string, IndexDecl>;
939
+ }
940
+ /** Column refs of a builder-field class, for its `static indexes`. */
941
+ type ClassRefs<C extends new () => object> = TypedColumnRefs<BuilderFields<InstanceType<C>>>;
942
+ /**
943
+ * Validation a column's SQL type can't express, on a builder field. The rule
944
+ * has to fit the column: `@Rule({ minLength: 2 })` on an integer column is a
945
+ * type error.
946
+ */
947
+ declare function Rule(rule: StringRule): <K extends string>(prototype: { [P in K]: ColumnBuilder<string>; }, key: K) => void;
948
+ declare function Rule(rule: NumberRule): <K extends string>(prototype: { [P in K]: ColumnBuilder<number>; }, key: K) => void;
949
+ declare function Rule(rule: SchemaLike): (prototype: object, key: string) => void;
950
+ /**
951
+ * The table a builder-field class declares — built once, then the same
952
+ * object on every call. Fields that aren't column builders are ignored.
953
+ */
954
+ declare function tableFromClass<C extends TableClass>(cls: C): TableDecl<`${C['tableName']}`, BuilderFields<InstanceType<C>>, C extends {
955
+ schema: infer S;
956
+ } ? SchemaOf<S> : undefined> & TypedColumnRefs<BuilderFields<InstanceType<C>>>;
957
+ type RowOf<C extends ColumnsRecord> = { [K in keyof C]: C[K] extends ColumnBuilder<infer T> ? C[K] extends NotNullBrand ? T : T | null : never; };
958
+ /**
959
+ * A class for a table: `class User extends TableBase('users', { ... }) {}`.
960
+ * The columns are an object literal, so types infer exactly as with
961
+ * `table()`. The class is the row type and can hold methods; `User.table` is
962
+ * the table, and exporting the class is enough for `kick db generate` and
963
+ * `createDbClient({ schema })`.
964
+ */
965
+ declare function TableBase<const N extends string, C extends ColumnsRecord, const S extends string | undefined = undefined>(name: N, columns: C, options?: {
966
+ schema?: S;
967
+ rules?: { [K in keyof C]?: RuleFor<C[K]>; };
968
+ indexes?: (refs: TypedColumnRefs<C>) => Record<string, IndexDecl>;
969
+ }): (abstract new () => RowOf<C>) & {
970
+ readonly table: TableDecl<N, C, SchemaOf<S>> & TypedColumnRefs<C>;
971
+ from<T>(this: new () => T, row: RowOf<C>): T;
972
+ };
973
+ /** A table being declared column by column — see {@link defineTable}. */
974
+ declare class TableDefinition<N extends string, C extends ColumnsRecord, S extends string | undefined> {
975
+ private readonly name;
976
+ private readonly schema;
977
+ private readonly columns;
978
+ private readonly columnRules;
979
+ private readonly constraints;
980
+ /** Shared by every step of one chain; `build()` fills it in. */
981
+ private readonly built;
982
+ constructor(name: N, schema: S, columns: C, columnRules: Rules, constraints: Constraints | undefined,
983
+ /** Shared by every step of one chain; `build()` fills it in. */
984
+ built: {
985
+ decl?: Record<string, ColumnRef>;
986
+ });
987
+ /**
988
+ * Add a column. A name already declared is a type error, and `rule` must
989
+ * fit the column. `builder` may be a function of the columns declared so
990
+ * far — a self-reference with no annotation, key and type checked:
991
+ * `.column('parentId', (t) => fk(uuid(), () => t.id))`.
992
+ */
993
+ column<const K extends string, B extends ColumnBuilder>(key: K extends keyof C ? never : K, builder: B | ((refs: TypedColumnRefs<C>) => B), rule?: RuleFor<B>): TableDefinition<N, C & { [P in K]: B; }, S>;
994
+ /** Indexes / unique constraints over the columns declared so far. Calls add up. */
995
+ index(constraints: (refs: TypedColumnRefs<C>) => Record<string, IndexDecl>): TableDefinition<N, C, S>;
996
+ build(): TableDecl<N, C, SchemaOf<S>> & TypedColumnRefs<C>;
997
+ /**
998
+ * Refs for `.column(key, (t) => ...)` callbacks. The table doesn't exist
999
+ * yet, so each ref resolves when a foreign-key thunk runs — after `build()`.
1000
+ */
1001
+ private lazyRefs;
1002
+ }
1003
+ /**
1004
+ * Declare a table column by column:
1005
+ * `defineTable('users').column('id', uuid().primaryKey()).build()`.
1006
+ */
1007
+ declare function defineTable<const N extends string, const S extends string | undefined = undefined>(name: N, options?: {
1008
+ schema?: S;
1009
+ }): TableDefinition<N, {}, S>;
1010
+ /**
1011
+ * A foreign key whose target must hold the same type:
1012
+ * `authorId: fk(uuid().notNull(), () => users.id)` — a uuid column pointing
1013
+ * at a serial key is a type error. Same as `.references()` at runtime.
1014
+ */
1015
+ declare function fk<T, B extends ColumnBuilder<T>>(builder: B & ColumnBuilder<T>, target: () => TypedColumnRef<NoInfer<T>>, options?: Parameters<ColumnBuilder['references']>[1]): B;
1016
+ /**
1017
+ * Add a foreign key to a column after both tables exist — how two tables
1018
+ * reference each other without an annotation:
1019
+ *
1020
+ * const users = table('users', { id: uuid().primaryKey(), featuredPostId: integer() })
1021
+ * const posts = table('posts', { id: serial().primaryKey(), authorId: fk(uuid(), () => users.id) })
1022
+ * link(users.featuredPostId, () => posts.id)
1023
+ *
1024
+ * Declared inside the initializers, each table's type would wait on the
1025
+ * other's (TS7022). References are read at snapshot time, so adding one
1026
+ * afterwards is the same as declaring it.
1027
+ */
1028
+ declare function link<T>(column: TypedColumnRef<T>, target: () => TypedColumnRef<NoInfer<T>>, options?: Parameters<ColumnBuilder['references']>[1]): void;
1029
+ //#endregion
1215
1030
  //#region src/dsl/relations.d.ts
1216
1031
  /**
1217
1032
  * Generic over the target table so the typegen plugin can pull
@@ -1227,8 +1042,7 @@ interface RelationOne<TTarget extends TableDecl<string, Record<string, ColumnBui
1227
1042
  /**
1228
1043
  * Disambiguates this relation from sibling `one` relations on the
1229
1044
  * same source table that point at the same target. Pair with the
1230
- * matching `relationName` on the inverse `many` side. See
1231
- * docs/db/spec-relation-name.md.
1045
+ * matching `relationName` on the inverse `many` side.
1232
1046
  */
1233
1047
  relationName?: string;
1234
1048
  }
@@ -1409,8 +1223,6 @@ declare class RelationalQueryAliasCollisionError extends KickDbError {
1409
1223
  * `AbortController.abort(reason)` — on the `cause` field for adopter
1410
1224
  * inspection (e.g. distinguishing HTTP timeout from explicit
1411
1225
  * cancellation from user-disconnect).
1412
- *
1413
- * Spec: docs/db/spec-abortsignal-threading.md.
1414
1226
  */
1415
1227
  declare class RelationalQueryCancelledError extends KickDbError {
1416
1228
  readonly cause?: unknown;
@@ -1430,8 +1242,7 @@ declare class RelationalQueryNotSupportedError extends KickDbError {
1430
1242
  * on the **target** table shares the same `relationName` AND points
1431
1243
  * back at the same source — the actual ambiguity case for resolver
1432
1244
  * step 1. Scope is per `(sourceTable, targetTable, relationName)`:
1433
- * the same tag can be reused across unrelated table pairs. Spec:
1434
- * docs/db/spec-relation-name.md §7 R-2.
1245
+ * the same tag can be reused across unrelated table pairs.
1435
1246
  */
1436
1247
  declare class RelationalQueryAmbiguousRelationNameError extends KickDbError {
1437
1248
  readonly sourceTable: string;
@@ -1528,5 +1339,5 @@ declare function markDialect<T extends object>(dialect: T, tag: DialectTag): T;
1528
1339
  */
1529
1340
  declare function readDialectMark(dialect: object): DialectTag | undefined;
1530
1341
  //#endregion
1531
- export { GenerateOptions as $, RenameTable as $n, SqliteIntrospectDb as $t, bigSerial as A, detectCompositeReferences as An, index as At, json as B, AlterColumn as Bn, DB_CLIENT as Bt, Relation as C, MigrationHashError as Cn, SchemaToTypes as Ct, relations as D, CompositeEnumReferenceError as Dn, qualifiedTableName as Dt, RelationsDecl as E, UnreviewedMigrationError as En, buildTable as Et, date as F, diff as Fn, FkSpec as Ft, smallSerial as G, CreateTable as Gn, kickDbAdapter as Gt, numeric as H, ChangeSet as Hn, DB_REPLICA as Ht, decimal as I, AddColumn as In, GeneratedBrand as It, time as J, DropForeignKey as Jn, checkDrift as Jt, smallint as K, DropColumn as Kn, DriftBehavior as Kt, doublePrecision as L, AddEnumValue as Ln, KICK_GENERATED as Lt, boolean as M, RemovedValueAsDefaultError as Mn, ColumnBuilder as Mt, bytea as N, hasAmbiguousReverse as Nn, ColumnRef as Nt, TimestampBuilder as O, CompositeQueryRunner as On, table as Ot, char as P, invertChanges as Pn, ColumnState as Pt, varchar as Q, RenameColumn as Qn, IntrospectSqliteOptions as Qt, integer as R, AddForeignKey as Rn, KICK_NOT_NULL as Rt, customType as S, MigrationError as Sn, createDbClient as St, RelationOne as T, SchemaDiffSummary as Tn, TableDecl as Tt, real as U, CreateEnum as Un, KickDbAdapterConfig as Ut, jsonb as V, Change as Vn, DB_PRIMARY as Vt, serial as W, CreateSchema as Wn, MigrationsOnBoot as Wt, timestamptz as X, DropTable as Xn, MysqlIntrospectDb as Xt, timestamp as Y, DropIndex as Yn, IntrospectMysqlOptions as Yt, uuid as Z, RemoveEnumValue as Zn, introspectMysql as Zt, SchemaToRelationsRegister as _, EnumDropHeader as _n, migrateLatest as _t, markDialect as a, KICK_LOCK_TABLE as an, Dialect$1 as ar, emitMysql as at, CustomColumnBuilder as b, MigrationDriftError as bn, migrateUp as bt, escapeLike as c, migrationsTableDdl as cn, ForeignKeySnapshot as cr, emitPg as ct, RelationalQueryAmbiguousRelationNameError as d, Journal as dn, SchemaSnapshot as dr, AppliedSummary as dt, introspectSqlite as en, renderSchemaSource as er, GenerateResult as et, RelationalQueryCancelledError as f, JournalEntry as fn, TableSnapshot as fr, ReversedSummary as ft, RelationalQueryUnknownRelationError as g, verifyMigrationHash as gn, migrateDown as gt, RelationalQueryNotSupportedError as h, readJournal as hn, StatusEntry as ht, isDialectTag as i, MemoryMigrationAdapter as in, ColumnSnapshot as ir, resolveDbConfig as it, bigint as j, KickDbError as jn, unique as jt, UuidBuilder as k, CompositeRef as kn, IndexDecl as kt, likePattern as l, MigrationAdapter as ln, IndexSnapshot as lr, ReviewResult as lt, RelationalQueryMissingInverseError as m, computeMigrationHash as mn, RunnerOptions as mt, DialectTag as n, IntrospectPgOptions as nn, extractSnapshot as nr, DbConfig as nt, readDialectMark as o, KICK_MIGRATIONS_TABLE as on, EnumSnapshot as or, SqliteRebuildRequiredError as ot, RelationalQueryDepthError as p, appendJournalEntry as pn, RollbackSummary as pt, text as q, DropEnum as qn, DriftLogger as qt, KICK_DIALECT as r, PgQueryRunner as rn, CheckSnapshot as rr, MigrationAdapterFactory as rt, LikeMatchMode as s, lockTableDdl as sn, FkAction as sr, emitSqlite as st, ReadonlyKysely as t, introspectPg as tn, fitIdentifier as tr, generate as tt, RelationalQueryAliasCollisionError as u, MigrationRow as un, RelationSnapshot as ur, reviewMigration as ut, ResolvedRelation as v, enforceEnumDropGate as vn, migrateRollback as vt, RelationMany as w, MigrationLockError as wn, QualifiedName as wt, CustomTypeOptions as x, MigrationEnumDropError as xn, safeNullComparison as xt, ResolvedRelations as y, parseEnumDropHeader as yn, migrateStatus as yt, interval as z, AddIndex as zn, NotNullBrand as zt };
1532
- //# sourceMappingURL=index-BJipaUa3.d.mts.map
1342
+ export { json as $, extractSnapshot as $n, IntrospectPgOptions as $t, Rule as A, hasAmbiguousReverse as An, migrateLatest as At, selfRef as B, CreateEnum as Bn, KickDbAdapterConfig as Bt, Relation as C, UnreviewedMigrationError as Cn, reviewMigration as Ct, relations as D, detectCompositeReferences as Dn, RunnerOptions as Dt, RelationsDecl as E, CompositeRef as En, RollbackSummary as Et, TableDefinition as F, AddForeignKey as Fn, createDbClient as Ft, boolean as G, DropForeignKey as Gn, checkDrift as Gt, UuidBuilder as H, CreateTable as Hn, kickDbAdapter as Ht, defineTable as I, AddIndex as In, SchemaToTypes as It, date as J, RemoveEnumValue as Jn, introspectMysql as Jt, bytea as K, DropIndex as Kn, IntrospectMysqlOptions as Kt, fk as L, AlterColumn as Ln, DB_CLIENT as Lt, StringRule as M, diff as Mn, migrateStatus as Mt, TableBase as N, AddColumn as Nn, migrateUp as Nt, ClassRefs as O, KickDbError as On, StatusEntry as Ot, TableClass as P, AddEnumValue as Pn, safeNullComparison as Pt, interval as Q, fitIdentifier as Qn, introspectPg as Qt, link as R, Change as Rn, DB_PRIMARY as Rt, customType as S, SchemaDiffSummary as Sn, ReviewResult as St, RelationOne as T, CompositeQueryRunner as Tn, ReversedSummary as Tt, bigSerial as U, DropColumn as Un, DriftBehavior as Ut, TimestampBuilder as V, CreateSchema as Vn, MigrationsOnBoot as Vt, bigint as W, DropEnum as Wn, DriftLogger as Wt, doublePrecision as X, RenameTable as Xn, SqliteIntrospectDb as Xt, decimal as Y, RenameColumn as Yn, IntrospectSqliteOptions as Yt, integer as Z, renderSchemaSource as Zn, introspectSqlite as Zt, SchemaToRelationsRegister as _, MigrationDriftError as _n, resolveDbConfig as _t, markDialect as a, migrationsTableDdl as an, smallint as at, CustomColumnBuilder as b, MigrationHashError as bn, emitSqlite as bt, escapeLike as c, Journal as cn, timestamp as ct, RelationalQueryAmbiguousRelationNameError as d, computeMigrationHash as dn, varchar as dt, PgQueryRunner as en, jsonb as et, RelationalQueryCancelledError as f, readJournal as fn, GenerateOptions as ft, RelationalQueryUnknownRelationError as g, parseEnumDropHeader as gn, MigrationAdapterFactory as gt, RelationalQueryNotSupportedError as h, enforceEnumDropGate as hn, DbConfig as ht, isDialectTag as i, lockTableDdl as in, smallSerial as it, RuleFor as j, invertChanges as jn, migrateRollback as jt, NumberRule as k, RemovedValueAsDefaultError as kn, migrateDown as kt, likePattern as l, JournalEntry as ln, timestamptz as lt, RelationalQueryMissingInverseError as m, EnumDropHeader as mn, generate as mt, DialectTag as n, KICK_LOCK_TABLE as nn, real as nt, readDialectMark as o, MigrationAdapter as on, text as ot, RelationalQueryDepthError as p, verifyMigrationHash as pn, GenerateResult as pt, char as q, DropTable as qn, MysqlIntrospectDb as qt, KICK_DIALECT as r, KICK_MIGRATIONS_TABLE as rn, serial as rt, LikeMatchMode as s, MigrationRow as sn, time as st, ReadonlyKysely as t, MemoryMigrationAdapter as tn, numeric as tt, RelationalQueryAliasCollisionError as u, appendJournalEntry as un, uuid as ut, ResolvedRelation as v, MigrationEnumDropError as vn, emitMysql as vt, RelationMany as w, CompositeEnumReferenceError as wn, AppliedSummary as wt, CustomTypeOptions as x, MigrationLockError as xn, emitPg as xt, ResolvedRelations as y, MigrationError as yn, SqliteRebuildRequiredError as yt, tableFromClass as z, ChangeSet as zn, DB_REPLICA as zt };
1343
+ //# sourceMappingURL=index-BQQWKybR.d.mts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"index-BQQWKybR.d.mts","names":[],"sources":["../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/migrate/errors.ts","../src/migrate/enum-drop-gate.ts","../src/migrate/journal.ts","../src/migrate/adapter.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/drift.ts","../src/adapter.ts","../src/tokens.ts","../src/client/schema-types.ts","../src/client/create.ts","../src/client/plugins.ts","../src/migrate/runner.ts","../src/migrate/review.ts","../src/emit/pg.ts","../src/emit/sqlite.ts","../src/emit/mysql.ts","../src/cli/config.ts","../src/cli/generate.ts","../src/dsl/columns/builders.ts","../src/dsl/self-ref.ts","../src/dsl/table-forms.ts","../src/dsl/relations.ts","../src/custom-type.ts","../src/query/relations.ts","../src/query/schema-relations-types.ts","../src/query/errors.ts","../src/query/like.ts","../src/dialect-marker.ts"],"mappings":"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"}
package/dist/index.d.mts CHANGED
@@ -1,4 +1,5 @@
1
1
 
2
- import { $ as GenerateOptions, $n as RenameTable, $t as SqliteIntrospectDb, A as bigSerial, An as detectCompositeReferences, At as index, B as json, Bn as AlterColumn, Bt as DB_CLIENT, C as Relation, Cn as MigrationHashError, Ct as SchemaToTypes, D as relations, Dn as CompositeEnumReferenceError, Dt as qualifiedTableName, E as RelationsDecl, En as UnreviewedMigrationError, Et as buildTable, F as date, Fn as diff, Ft as FkSpec, G as smallSerial, Gn as CreateTable, Gt as kickDbAdapter, H as numeric, Hn as ChangeSet, Ht as DB_REPLICA, I as decimal, In as AddColumn, It as GeneratedBrand, J as time, Jn as DropForeignKey, Jt as checkDrift, K as smallint, Kn as DropColumn, Kt as DriftBehavior, L as doublePrecision, Ln as AddEnumValue, Lt as KICK_GENERATED, M as boolean, Mn as RemovedValueAsDefaultError, Mt as ColumnBuilder, N as bytea, Nn as hasAmbiguousReverse, Nt as ColumnRef, O as TimestampBuilder, On as CompositeQueryRunner, Ot as table, P as char, Pn as invertChanges, Pt as ColumnState, Q as varchar, Qn as RenameColumn, Qt as IntrospectSqliteOptions, R as integer, Rn as AddForeignKey, Rt as KICK_NOT_NULL, S as customType, Sn as MigrationError, St as createDbClient, T as RelationOne, Tn as SchemaDiffSummary, Tt as TableDecl, U as real, Un as CreateEnum, Ut as KickDbAdapterConfig, V as jsonb, Vn as Change, Vt as DB_PRIMARY, W as serial, Wn as CreateSchema, Wt as MigrationsOnBoot, X as timestamptz, Xn as DropTable, Xt as MysqlIntrospectDb, Y as timestamp, Yn as DropIndex, Yt as IntrospectMysqlOptions, Z as uuid, Zn as RemoveEnumValue, Zt as introspectMysql, _ as SchemaToRelationsRegister, _n as EnumDropHeader, _t as migrateLatest, a as markDialect, an as KICK_LOCK_TABLE, ar as Dialect, at as emitMysql, b as CustomColumnBuilder, bn as MigrationDriftError, bt as migrateUp, c as escapeLike, cn as migrationsTableDdl, cr as ForeignKeySnapshot, ct as emitPg, d as RelationalQueryAmbiguousRelationNameError, dn as Journal, dr as SchemaSnapshot, dt as AppliedSummary, en as introspectSqlite, er as renderSchemaSource, et as GenerateResult, f as RelationalQueryCancelledError, fn as JournalEntry, fr as TableSnapshot, ft as ReversedSummary, g as RelationalQueryUnknownRelationError, gn as verifyMigrationHash, gt as migrateDown, h as RelationalQueryNotSupportedError, hn as readJournal, ht as StatusEntry, i as isDialectTag, in as MemoryMigrationAdapter, ir as ColumnSnapshot, it as resolveDbConfig, j as bigint, jn as KickDbError, jt as unique, k as UuidBuilder, kn as CompositeRef, kt as IndexDecl, l as likePattern, ln as MigrationAdapter, lr as IndexSnapshot, lt as ReviewResult, m as RelationalQueryMissingInverseError, mn as computeMigrationHash, mt as RunnerOptions, n as DialectTag, nn as IntrospectPgOptions, nr as extractSnapshot, nt as DbConfig, o as readDialectMark, on as KICK_MIGRATIONS_TABLE, or as EnumSnapshot, ot as SqliteRebuildRequiredError, p as RelationalQueryDepthError, pn as appendJournalEntry, pt as RollbackSummary, q as text, qn as DropEnum, qt as DriftLogger, r as KICK_DIALECT, rn as PgQueryRunner, rr as CheckSnapshot, s as LikeMatchMode, sn as lockTableDdl, sr as FkAction, st as emitSqlite, t as ReadonlyKysely, tn as introspectPg, tr as fitIdentifier, tt as generate, u as RelationalQueryAliasCollisionError, un as MigrationRow, ur as RelationSnapshot, ut as reviewMigration, v as ResolvedRelation, vn as enforceEnumDropGate, vt as migrateRollback, w as RelationMany, wn as MigrationLockError, wt as QualifiedName, x as CustomTypeOptions, xn as MigrationEnumDropError, xt as safeNullComparison, y as ResolvedRelations, yn as parseEnumDropHeader, yt as migrateStatus, z as interval, zn as AddIndex, zt as NotNullBrand } from "./index-BJipaUa3.mjs";
3
- import { C as ModelExtensions, S as ExtensionDefinition, _ as TableRelations, a as QueryErrorEvent, b as RegisteredDB, c as TransactionEvent, d as FindManyRow, f as KickDbRelationsRegister, g as TableQueryNamespace, h as RelationMapEntry, i as KickDbClientEvents, l as TransactionRollbackEvent, m as RegisteredRelations, n as CreateDbClientOptions, o as QueryEvent, p as QueryNamespace, r as KickDbClient, t as BeforeQueryEvent, u as FindManyOptions, v as WithClause, x as ExtendedClient, y as KickDbRegister } from "./types-NkfgZHEN.mjs";
4
- export { type AddColumn, type AddEnumValue, type AddForeignKey, type AddIndex, type AlterColumn, type AppliedSummary, type BeforeQueryEvent, type Change, type ChangeSet, type CheckSnapshot, ColumnBuilder, type ColumnRef, type ColumnSnapshot, type ColumnState, CompositeEnumReferenceError, type CompositeQueryRunner, type CompositeRef, type CreateDbClientOptions, type CreateEnum, type CreateSchema, type CreateTable, CustomColumnBuilder, type CustomTypeOptions, DB_CLIENT, DB_PRIMARY, DB_REPLICA, type DbConfig, type Dialect, type DialectTag, type DriftBehavior, type DriftLogger, type DropColumn, type DropEnum, type DropForeignKey, type DropIndex, type DropTable, type EnumDropHeader, type EnumSnapshot, type ExtendedClient, type ExtensionDefinition, type FindManyOptions, type FindManyRow, type FkAction, type FkSpec, type ForeignKeySnapshot, type GenerateOptions, type GenerateResult, type GeneratedBrand, IndexDecl, type IndexSnapshot, type IntrospectMysqlOptions, type IntrospectPgOptions, type IntrospectSqliteOptions, type Journal, type JournalEntry, KICK_DIALECT, KICK_GENERATED, KICK_LOCK_TABLE, KICK_MIGRATIONS_TABLE, KICK_NOT_NULL, type KickDbAdapterConfig, type KickDbClient, type KickDbClientEvents, KickDbError, type KickDbRegister, type KickDbRelationsRegister, type LikeMatchMode, MemoryMigrationAdapter, type MigrationAdapter, MigrationDriftError, MigrationEnumDropError, MigrationError, MigrationHashError, MigrationLockError, type MigrationRow, type MigrationsOnBoot, type ModelExtensions, type MysqlIntrospectDb, type NotNullBrand, type PgQueryRunner, QualifiedName, type QueryErrorEvent, type QueryEvent, type QueryNamespace, type ReadonlyKysely, type RegisteredDB, type RegisteredRelations, Relation, RelationMany, type RelationMapEntry, RelationOne, type RelationSnapshot, RelationalQueryAliasCollisionError, RelationalQueryAmbiguousRelationNameError, RelationalQueryCancelledError, RelationalQueryDepthError, RelationalQueryMissingInverseError, RelationalQueryNotSupportedError, RelationalQueryUnknownRelationError, RelationsDecl, type RemoveEnumValue, RemovedValueAsDefaultError, type RenameColumn, type RenameTable, type ResolvedRelation, type ResolvedRelations, type ReversedSummary, type ReviewResult, type RollbackSummary, type RunnerOptions, type SchemaDiffSummary, type SchemaSnapshot, type SchemaToRelationsRegister, type SchemaToTypes, type SqliteIntrospectDb, SqliteRebuildRequiredError, type StatusEntry, TableDecl, type TableQueryNamespace, type TableRelations, type TableSnapshot, TimestampBuilder, type TransactionEvent, type TransactionRollbackEvent, UnreviewedMigrationError, UuidBuilder, type WithClause, appendJournalEntry, bigSerial, bigint, boolean, buildTable, bytea, char, checkDrift, computeMigrationHash, createDbClient, customType, date, decimal, detectCompositeReferences, diff, doublePrecision, emitMysql, emitPg, emitSqlite, enforceEnumDropGate, escapeLike, extractSnapshot, fitIdentifier, generate, hasAmbiguousReverse, index, integer, interval, introspectMysql, introspectPg, introspectSqlite, invertChanges, isDialectTag, json, jsonb, kickDbAdapter, likePattern, lockTableDdl, markDialect, migrateDown, migrateLatest, migrateRollback, migrateStatus, migrateUp, migrationsTableDdl, numeric, parseEnumDropHeader, qualifiedTableName, readDialectMark, readJournal, real, relations, renderSchemaSource, resolveDbConfig, reviewMigration, safeNullComparison, serial, smallSerial, smallint, table, text, time, timestamp, timestamptz, unique, uuid, varchar, verifyMigrationHash };
2
+ import { A as TypedColumnRefs, B as TableSnapshot, C as ColumnState, D as KICK_NOT_NULL, E as KICK_GENERATED, F as FkAction, I as ForeignKeySnapshot, L as IndexSnapshot, M as ColumnSnapshot, N as Dialect, O as NotNullBrand, P as EnumSnapshot, R as RelationSnapshot, S as ColumnRef, T as GeneratedBrand, _ as unwrapTable, b as unique, f as QualifiedName, g as table, h as qualifiedTableName, j as CheckSnapshot, k as TypedColumnRef, m as buildTable, p as TableDecl, v as IndexDecl, w as FkSpec, x as ColumnBuilder, y as index, z as SchemaSnapshot } from "./schema-DDMkteEP.mjs";
3
+ import { $ as json, $n as extractSnapshot, $t as IntrospectPgOptions, A as Rule, An as hasAmbiguousReverse, At as migrateLatest, B as selfRef, Bn as CreateEnum, Bt as KickDbAdapterConfig, C as Relation, Cn as UnreviewedMigrationError, Ct as reviewMigration, D as relations, Dn as detectCompositeReferences, Dt as RunnerOptions, E as RelationsDecl, En as CompositeRef, Et as RollbackSummary, F as TableDefinition, Fn as AddForeignKey, Ft as createDbClient, G as boolean, Gn as DropForeignKey, Gt as checkDrift, H as UuidBuilder, Hn as CreateTable, Ht as kickDbAdapter, I as defineTable, In as AddIndex, It as SchemaToTypes, J as date, Jn as RemoveEnumValue, Jt as introspectMysql, K as bytea, Kn as DropIndex, Kt as IntrospectMysqlOptions, L as fk, Ln as AlterColumn, Lt as DB_CLIENT, M as StringRule, Mn as diff, Mt as migrateStatus, N as TableBase, Nn as AddColumn, Nt as migrateUp, O as ClassRefs, On as KickDbError, Ot as StatusEntry, P as TableClass, Pn as AddEnumValue, Pt as safeNullComparison, Q as interval, Qn as fitIdentifier, Qt as introspectPg, R as link, Rn as Change, Rt as DB_PRIMARY, S as customType, Sn as SchemaDiffSummary, St as ReviewResult, T as RelationOne, Tn as CompositeQueryRunner, Tt as ReversedSummary, U as bigSerial, Un as DropColumn, Ut as DriftBehavior, V as TimestampBuilder, Vn as CreateSchema, Vt as MigrationsOnBoot, W as bigint, Wn as DropEnum, Wt as DriftLogger, X as doublePrecision, Xn as RenameTable, Xt as SqliteIntrospectDb, Y as decimal, Yn as RenameColumn, Yt as IntrospectSqliteOptions, Z as integer, Zn as renderSchemaSource, Zt as introspectSqlite, _ as SchemaToRelationsRegister, _n as MigrationDriftError, _t as resolveDbConfig, a as markDialect, an as migrationsTableDdl, at as smallint, b as CustomColumnBuilder, bn as MigrationHashError, bt as emitSqlite, c as escapeLike, cn as Journal, ct as timestamp, d as RelationalQueryAmbiguousRelationNameError, dn as computeMigrationHash, dt as varchar, en as PgQueryRunner, et as jsonb, f as RelationalQueryCancelledError, fn as readJournal, ft as GenerateOptions, g as RelationalQueryUnknownRelationError, gn as parseEnumDropHeader, h as RelationalQueryNotSupportedError, hn as enforceEnumDropGate, ht as DbConfig, i as isDialectTag, in as lockTableDdl, it as smallSerial, j as RuleFor, jn as invertChanges, jt as migrateRollback, k as NumberRule, kn as RemovedValueAsDefaultError, kt as migrateDown, l as likePattern, ln as JournalEntry, lt as timestamptz, m as RelationalQueryMissingInverseError, mn as EnumDropHeader, mt as generate, n as DialectTag, nn as KICK_LOCK_TABLE, nt as real, o as readDialectMark, on as MigrationAdapter, ot as text, p as RelationalQueryDepthError, pn as verifyMigrationHash, pt as GenerateResult, q as char, qn as DropTable, qt as MysqlIntrospectDb, r as KICK_DIALECT, rn as KICK_MIGRATIONS_TABLE, rt as serial, s as LikeMatchMode, sn as MigrationRow, st as time, t as ReadonlyKysely, tn as MemoryMigrationAdapter, tt as numeric, u as RelationalQueryAliasCollisionError, un as appendJournalEntry, ut as uuid, v as ResolvedRelation, vn as MigrationEnumDropError, vt as emitMysql, w as RelationMany, wn as CompositeEnumReferenceError, wt as AppliedSummary, x as CustomTypeOptions, xn as MigrationLockError, xt as emitPg, y as ResolvedRelations, yn as MigrationError, yt as SqliteRebuildRequiredError, z as tableFromClass, zn as ChangeSet, zt as DB_REPLICA } from "./index-BQQWKybR.mjs";
4
+ import { C as ModelExtensions, S as ExtensionDefinition, _ as TableRelations, a as QueryErrorEvent, b as RegisteredDB, c as TransactionEvent, d as FindManyRow, f as KickDbRelationsRegister, g as TableQueryNamespace, h as RelationMapEntry, i as KickDbClientEvents, l as TransactionRollbackEvent, m as RegisteredRelations, n as CreateDbClientOptions, o as QueryEvent, p as QueryNamespace, r as KickDbClient, t as BeforeQueryEvent, u as FindManyOptions, v as WithClause, x as ExtendedClient, y as KickDbRegister } from "./types-DtvYnaXL.mjs";
5
+ export { type AddColumn, type AddEnumValue, type AddForeignKey, type AddIndex, type AlterColumn, type AppliedSummary, type BeforeQueryEvent, type Change, type ChangeSet, type CheckSnapshot, type ClassRefs, ColumnBuilder, type ColumnRef, type ColumnSnapshot, type ColumnState, CompositeEnumReferenceError, type CompositeQueryRunner, type CompositeRef, type CreateDbClientOptions, type CreateEnum, type CreateSchema, type CreateTable, CustomColumnBuilder, type CustomTypeOptions, DB_CLIENT, DB_PRIMARY, DB_REPLICA, type DbConfig, type Dialect, type DialectTag, type DriftBehavior, type DriftLogger, type DropColumn, type DropEnum, type DropForeignKey, type DropIndex, type DropTable, type EnumDropHeader, type EnumSnapshot, type ExtendedClient, type ExtensionDefinition, type FindManyOptions, type FindManyRow, type FkAction, type FkSpec, type ForeignKeySnapshot, type GenerateOptions, type GenerateResult, type GeneratedBrand, IndexDecl, type IndexSnapshot, type IntrospectMysqlOptions, type IntrospectPgOptions, type IntrospectSqliteOptions, type Journal, type JournalEntry, KICK_DIALECT, KICK_GENERATED, KICK_LOCK_TABLE, KICK_MIGRATIONS_TABLE, KICK_NOT_NULL, type KickDbAdapterConfig, type KickDbClient, type KickDbClientEvents, KickDbError, type KickDbRegister, type KickDbRelationsRegister, type LikeMatchMode, MemoryMigrationAdapter, type MigrationAdapter, MigrationDriftError, MigrationEnumDropError, MigrationError, MigrationHashError, MigrationLockError, type MigrationRow, type MigrationsOnBoot, type ModelExtensions, type MysqlIntrospectDb, type NotNullBrand, type NumberRule, type PgQueryRunner, QualifiedName, type QueryErrorEvent, type QueryEvent, type QueryNamespace, type ReadonlyKysely, type RegisteredDB, type RegisteredRelations, Relation, RelationMany, type RelationMapEntry, RelationOne, type RelationSnapshot, RelationalQueryAliasCollisionError, RelationalQueryAmbiguousRelationNameError, RelationalQueryCancelledError, RelationalQueryDepthError, RelationalQueryMissingInverseError, RelationalQueryNotSupportedError, RelationalQueryUnknownRelationError, RelationsDecl, type RemoveEnumValue, RemovedValueAsDefaultError, type RenameColumn, type RenameTable, type ResolvedRelation, type ResolvedRelations, type ReversedSummary, type ReviewResult, type RollbackSummary, Rule, type RuleFor, type RunnerOptions, type SchemaDiffSummary, type SchemaSnapshot, type SchemaToRelationsRegister, type SchemaToTypes, type SqliteIntrospectDb, SqliteRebuildRequiredError, type StatusEntry, type StringRule, TableBase, type TableClass, TableDecl, TableDefinition, type TableQueryNamespace, type TableRelations, type TableSnapshot, TimestampBuilder, type TransactionEvent, type TransactionRollbackEvent, type TypedColumnRef, type TypedColumnRefs, UnreviewedMigrationError, UuidBuilder, type WithClause, appendJournalEntry, bigSerial, bigint, boolean, buildTable, bytea, char, checkDrift, computeMigrationHash, createDbClient, customType, date, decimal, defineTable, detectCompositeReferences, diff, doublePrecision, emitMysql, emitPg, emitSqlite, enforceEnumDropGate, escapeLike, extractSnapshot, fitIdentifier, fk, generate, hasAmbiguousReverse, index, integer, interval, introspectMysql, introspectPg, introspectSqlite, invertChanges, isDialectTag, json, jsonb, kickDbAdapter, likePattern, link, lockTableDdl, markDialect, migrateDown, migrateLatest, migrateRollback, migrateStatus, migrateUp, migrationsTableDdl, numeric, parseEnumDropHeader, qualifiedTableName, readDialectMark, readJournal, real, relations, renderSchemaSource, resolveDbConfig, reviewMigration, safeNullComparison, selfRef, serial, smallSerial, smallint, table, tableFromClass, text, time, timestamp, timestamptz, unique, unwrapTable, uuid, varchar, verifyMigrationHash };