@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.
- package/dist/cli.d.mts +10 -10
- package/dist/cli.d.mts.map +1 -1
- package/dist/cli.mjs +3 -3
- package/dist/cli.mjs.map +1 -1
- package/dist/custom-type-CZdUgkPT.mjs +12 -0
- package/dist/custom-type-CZdUgkPT.mjs.map +1 -0
- package/dist/devtools-events.d.mts +2 -1
- package/dist/devtools-events.mjs +1 -1
- package/dist/{index-BJipaUa3.d.mts → index-BQQWKybR.d.mts} +138 -327
- package/dist/index-BQQWKybR.d.mts.map +1 -0
- package/dist/index.d.mts +4 -3
- package/dist/index.mjs +2 -2
- package/dist/mysql.d.mts +11 -12
- package/dist/mysql.d.mts.map +1 -1
- package/dist/mysql.mjs +2 -2
- package/dist/mysql.mjs.map +1 -1
- package/dist/pg-CwNv938J.mjs +12 -0
- package/dist/pg-CwNv938J.mjs.map +1 -0
- package/dist/pg.d.mts +22 -22
- package/dist/pg.d.mts.map +1 -1
- package/dist/pg.mjs +2 -2
- package/dist/pg.mjs.map +1 -1
- package/dist/schema-DDMkteEP.d.mts +416 -0
- package/dist/schema-DDMkteEP.d.mts.map +1 -0
- package/dist/schema.d.mts +3 -0
- package/dist/schema.mjs +12 -0
- package/dist/schema.mjs.map +1 -0
- package/dist/sqlite.d.mts +7 -8
- package/dist/sqlite.d.mts.map +1 -1
- package/dist/sqlite.mjs +2 -2
- package/dist/{src-DVdBmsLe.mjs → src-BEJ33yHI.mjs} +9 -9
- package/dist/src-BEJ33yHI.mjs.map +1 -0
- package/dist/{types-NkfgZHEN.d.mts → types-DtvYnaXL.d.mts} +3 -4
- package/dist/types-DtvYnaXL.d.mts.map +1 -0
- package/package.json +11 -6
- package/dist/index-BJipaUa3.d.mts.map +0 -1
- package/dist/src-DVdBmsLe.mjs.map +0 -1
- package/dist/types-NkfgZHEN.d.mts.map +0 -1
|
@@ -1,118 +1,9 @@
|
|
|
1
1
|
|
|
2
|
-
import {
|
|
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.
|
|
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`).
|
|
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
|
-
*
|
|
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
|
-
|
|
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
|
-
} ?
|
|
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.
|
|
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.
|
|
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 {
|
|
1532
|
-
//# sourceMappingURL=index-
|
|
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 {
|
|
3
|
-
import { C as
|
|
4
|
-
|
|
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 };
|