drizzle-kit 0.20.0-f39d8bc → 0.20.0

package/@types/utils.d.ts

@@ -0,0 +1,12 @@
+declare global {
+    interface String {
+        trimChar(char: string): string;
+        squashSpaces(): string;
+        camelCase(): string;
+        concatIf(it: string, condition: boolean): string;
+    }
+    interface Array<T> {
+        random(): T;
+    }
+}
+export {};

package/cli/commands/migrate.d.ts

@@ -0,0 +1,260 @@
+import { CommonSchema, CommonSquashedSchema, Dialect } from "../../schemaValidator";
+import { schema } from "../views";
+import { PgSchema } from "src/serializer/pgSchema";
+import { SQLiteSchema } from "src/serializer/sqliteSchema";
+import { MySqlSchema } from "src/serializer/mysqlSchema";
+import { Journal } from "src/utils";
+import { GenerateConfig } from "./utils";
+export type Named = {
+    name: string;
+};
+export type NamedWithSchema = {
+    name: string;
+    schema?: string;
+};
+export declare const prepareAndMigratePg: (config: GenerateConfig) => Promise<void>;
+export declare const prepareMySQLPush: (config: {
+    schema: string | string[];
+}, snapshot: MySqlSchema) => Promise<{
+    sqlStatements: string[];
+    statements: import("../../jsonStatements").JsonStatement[];
+    validatedCur: {
+        internal?: {
+            tables: Record<string, {
+                columns: Record<string, {
+                    isDefaultAnExpression?: boolean | undefined;
+                } | undefined>;
+            } | undefined>;
+        } | undefined;
+        id: string;
+        prevId: string;
+        version: "5";
+        dialect: "mysql";
+        tables: Record<string, {
+            schema?: string | undefined;
+            name: string;
+            columns: Record<string, {
+                default?: any;
+                onUpdate?: any;
+                autoincrement?: boolean | undefined;
+                name: string;
+                type: string;
+                primaryKey: boolean;
+                notNull: boolean;
+            }>;
+            indexes: Record<string, {
+                using?: "btree" | "hash" | undefined;
+                algorithm?: "default" | "inplace" | "copy" | undefined;
+                lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+                name: string;
+                columns: string[];
+                isUnique: boolean;
+            }>;
+            foreignKeys: Record<string, {
+                onUpdate?: string | undefined;
+                onDelete?: string | undefined;
+                name: string;
+                tableFrom: string;
+                columnsFrom: string[];
+                tableTo: string;
+                columnsTo: string[];
+            }>;
+            compositePrimaryKeys: Record<string, {
+                name: string;
+                columns: string[];
+            }>;
+            uniqueConstraints: Record<string, {
+                name: string;
+                columns: string[];
+            }>;
+        }>;
+        schemas: Record<string, string>;
+        _meta: {
+            columns: Record<string, string>;
+            tables: Record<string, string>;
+            schemas: Record<string, string>;
+        };
+    };
+    validatedPrev: {
+        internal?: {
+            tables: Record<string, {
+                columns: Record<string, {
+                    isDefaultAnExpression?: boolean | undefined;
+                } | undefined>;
+            } | undefined>;
+        } | undefined;
+        id: string;
+        prevId: string;
+        version: "5";
+        dialect: "mysql";
+        tables: Record<string, {
+            schema?: string | undefined;
+            name: string;
+            columns: Record<string, {
+                default?: any;
+                onUpdate?: any;
+                autoincrement?: boolean | undefined;
+                name: string;
+                type: string;
+                primaryKey: boolean;
+                notNull: boolean;
+            }>;
+            indexes: Record<string, {
+                using?: "btree" | "hash" | undefined;
+                algorithm?: "default" | "inplace" | "copy" | undefined;
+                lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+                name: string;
+                columns: string[];
+                isUnique: boolean;
+            }>;
+            foreignKeys: Record<string, {
+                onUpdate?: string | undefined;
+                onDelete?: string | undefined;
+                name: string;
+                tableFrom: string;
+                columnsFrom: string[];
+                tableTo: string;
+                columnsTo: string[];
+            }>;
+            compositePrimaryKeys: Record<string, {
+                name: string;
+                columns: string[];
+            }>;
+            uniqueConstraints: Record<string, {
+                name: string;
+                columns: string[];
+            }>;
+        }>;
+        schemas: Record<string, string>;
+        _meta: {
+            columns: Record<string, string>;
+            tables: Record<string, string>;
+            schemas: Record<string, string>;
+        };
+    };
+} | undefined>;
+export declare const prepareSQLitePush: (config: {
+    schema: string | string[];
+}, snapshot: SQLiteSchema) => Promise<{
+    sqlStatements: string[];
+    statements: import("../../jsonStatements").JsonStatement[];
+    squashedPrev: {
+        enums?: any;
+        version: "5";
+        dialect: "sqlite";
+        tables: Record<string, {
+            name: string;
+            columns: Record<string, {
+                default?: any;
+                autoincrement?: boolean | undefined;
+                name: string;
+                type: string;
+                primaryKey: boolean;
+                notNull: boolean;
+            }>;
+            indexes: Record<string, string>;
+            foreignKeys: Record<string, string>;
+            compositePrimaryKeys: Record<string, string>;
+            uniqueConstraints: Record<string, string>;
+        }>;
+    };
+    squashedCur: {
+        enums?: any;
+        version: "5";
+        dialect: "sqlite";
+        tables: Record<string, {
+            name: string;
+            columns: Record<string, {
+                default?: any;
+                autoincrement?: boolean | undefined;
+                name: string;
+                type: string;
+                primaryKey: boolean;
+                notNull: boolean;
+            }>;
+            indexes: Record<string, string>;
+            foreignKeys: Record<string, string>;
+            compositePrimaryKeys: Record<string, string>;
+            uniqueConstraints: Record<string, string>;
+        }>;
+    };
+    meta: {
+        schemas: {};
+        tables: {};
+        columns: {};
+    } | undefined;
+} | undefined>;
+export declare const preparePgPush: (config: {
+    schema: string | string[];
+}, snapshot: PgSchema, schemaFilter: string[]) => Promise<{
+    sqlStatements: string[];
+    statements: import("../../jsonStatements").JsonStatement[];
+    squashedPrev: {
+        version: "5";
+        dialect: "pg";
+        tables: Record<string, {
+            name: string;
+            columns: Record<string, {
+                isUnique?: any;
+                default?: any;
+                uniqueName?: string | undefined;
+                nullsNotDistinct?: boolean | undefined;
+                name: string;
+                type: string;
+                primaryKey: boolean;
+                notNull: boolean;
+            }>;
+            indexes: Record<string, string>;
+            foreignKeys: Record<string, string>;
+            schema: string;
+            compositePrimaryKeys: Record<string, string>;
+            uniqueConstraints: Record<string, string>;
+        }>;
+        schemas: Record<string, string>;
+        enums: Record<string, {
+            name: string;
+            values: Record<string, string>;
+        }>;
+    };
+    squashedCur: {
+        version: "5";
+        dialect: "pg";
+        tables: Record<string, {
+            name: string;
+            columns: Record<string, {
+                isUnique?: any;
+                default?: any;
+                uniqueName?: string | undefined;
+                nullsNotDistinct?: boolean | undefined;
+                name: string;
+                type: string;
+                primaryKey: boolean;
+                notNull: boolean;
+            }>;
+            indexes: Record<string, string>;
+            foreignKeys: Record<string, string>;
+            schema: string;
+            compositePrimaryKeys: Record<string, string>;
+            uniqueConstraints: Record<string, string>;
+        }>;
+        schemas: Record<string, string>;
+        enums: Record<string, {
+            name: string;
+            values: Record<string, string>;
+        }>;
+    };
+} | undefined>;
+export declare const prepareAndMigrateMySql: (config: GenerateConfig) => Promise<void>;
+export declare const prepareAndMigrateSqlite: (config: GenerateConfig) => Promise<void>;
+export declare const prepareSQL: (prev: CommonSquashedSchema, cur: CommonSquashedSchema, dialect: Dialect, prevFull?: any, curFull?: any) => Promise<{
+    statements: import("../../jsonStatements").JsonStatement[];
+    sqlStatements: string[];
+    _meta: {
+        schemas: {};
+        tables: {};
+        columns: {};
+    } | undefined;
+}>;
+export declare const BREAKPOINT = "--> statement-breakpoint\n";
+export declare const writeResult: (cur: CommonSchema, sqlStatements: string[], journal: Journal, _meta: any, outFolder: string, breakpoints: boolean, type?: "introspect" | "custom" | "none") => void;
+export declare const prepareSnapshotFolderName: () => string;

package/cli/commands/mysqlUp.d.ts

@@ -0,0 +1,4 @@
+import { MySqlSchema, MySqlSchemaV4 } from "src/serializer/mysqlSchema";
+export declare const upMysqlHandler: (out: string) => void;
+export declare const upMySqlHandlerV4toV5: (obj: MySqlSchemaV4) => MySqlSchema;
+export declare const upMysqlHandlerV4: (out: string) => void;

package/cli/commands/pgConnect.d.ts

@@ -0,0 +1,5 @@
+import type { PgConnectionConfig } from "../validations/pg";
+import { PgPostgres } from "src/drivers";
+export declare const connectToPg: (config: PgConnectionConfig) => Promise<{
+    client: PgPostgres;
+}>;

package/cli/commands/pgIntrospect.d.ts

@@ -0,0 +1,116 @@
+import type { PgConfigIntrospect } from "../validations/pg";
+import type { DrizzleDbClient } from "src/drivers";
+export declare const pgSchemas: (client: DrizzleDbClient) => Promise<string[]>;
+export declare const pgPushIntrospect: (connection: {
+    client: DrizzleDbClient;
+}, filters: string[], schemaFilters: string[]) => Promise<{
+    schema: {
+        id: string;
+        prevId: string;
+        version: "5";
+        dialect: "pg";
+        tables: Record<string, {
+            name: string;
+            columns: Record<string, {
+                isUnique?: any;
+                default?: any;
+                uniqueName?: string | undefined;
+                nullsNotDistinct?: boolean | undefined;
+                name: string;
+                type: string;
+                primaryKey: boolean;
+                notNull: boolean;
+            }>;
+            indexes: Record<string, {
+                name: string;
+                columns: string[];
+                isUnique: boolean;
+            }>;
+            foreignKeys: Record<string, {
+                onUpdate?: string | undefined;
+                onDelete?: string | undefined;
+                name: string;
+                tableFrom: string;
+                columnsFrom: string[];
+                tableTo: string;
+                columnsTo: string[];
+            }>;
+            schema: string;
+            compositePrimaryKeys: Record<string, {
+                name: string;
+                columns: string[];
+            }>;
+            uniqueConstraints: Record<string, {
+                name: string;
+                columns: string[];
+                nullsNotDistinct: boolean;
+            }>;
+        }>;
+        schemas: Record<string, string>;
+        _meta: {
+            columns: Record<string, string>;
+            tables: Record<string, string>;
+            schemas: Record<string, string>;
+        };
+        enums: Record<string, {
+            name: string;
+            values: Record<string, string>;
+        }>;
+    };
+}>;
+export declare const pgIntrospect: (config: PgConfigIntrospect, filters: string[], schemaFilters: string[]) => Promise<{
+    schema: {
+        id: string;
+        prevId: string;
+        version: "5";
+        dialect: "pg";
+        tables: Record<string, {
+            name: string;
+            columns: Record<string, {
+                isUnique?: any;
+                default?: any;
+                uniqueName?: string | undefined;
+                nullsNotDistinct?: boolean | undefined;
+                name: string;
+                type: string;
+                primaryKey: boolean;
+                notNull: boolean;
+            }>;
+            indexes: Record<string, {
+                name: string;
+                columns: string[];
+                isUnique: boolean;
+            }>;
+            foreignKeys: Record<string, {
+                onUpdate?: string | undefined;
+                onDelete?: string | undefined;
+                name: string;
+                tableFrom: string;
+                columnsFrom: string[];
+                tableTo: string;
+                columnsTo: string[];
+            }>;
+            schema: string;
+            compositePrimaryKeys: Record<string, {
+                name: string;
+                columns: string[];
+            }>;
+            uniqueConstraints: Record<string, {
+                name: string;
+                columns: string[];
+                nullsNotDistinct: boolean;
+            }>;
+        }>;
+        schemas: Record<string, string>;
+        _meta: {
+            columns: Record<string, string>;
+            tables: Record<string, string>;
+            schemas: Record<string, string>;
+        };
+        enums: Record<string, {
+            name: string;
+            values: Record<string, string>;
+        }>;
+    };
+    ts: string;
+}>;

package/cli/commands/pgPushUtils.d.ts

@@ -0,0 +1,14 @@
+import { DrizzleDbClient } from "src/drivers";
+import { JsonStatement } from "src/jsonStatements";
+export declare const pgSuggestions: ({ connection, statements, }: {
+    statements: JsonStatement[];
+    connection: DrizzleDbClient;
+}) => Promise<{
+    statementsToExecute: string[];
+    shouldAskForApprove: boolean;
+    infoToPrint: string[];
+    columnsToRemove: string[];
+    schemasToRemove: string[];
+    tablesToTruncate: string[];
+    tablesToRemove: string[];
+}>;

package/cli/commands/pgUp.d.ts

@@ -0,0 +1,4 @@
+import { PgSchema, PgSchemaV4 } from "src/serializer/pgSchema";
+export declare const upPgHandlerV4toV5: (obj: PgSchemaV4) => PgSchema;
+export declare const upPgHandler: (out: string) => void;
+export declare const upPgHandlerV4: (out: string) => void;

package/cli/commands/sqliteIntrospect.d.ts

@@ -0,0 +1,102 @@
+import type { SQLiteCliConfig, SQLiteConnectionConfig } from "./sqliteUtils";
+import type { DrizzleDbClient } from "../../drivers";
+export declare const connectToSQLite: (config: SQLiteConnectionConfig) => Promise<{
+    client: import("../../drivers").BetterSqlite;
+} | {
+    client?: undefined;
+}>;
+export declare const sqliteIntrospect: (config: SQLiteCliConfig, filters: string[]) => Promise<{
+    schema: {
+        id: string;
+        prevId: string;
+        version: "5";
+        dialect: "sqlite";
+        tables: Record<string, {
+            name: string;
+            columns: Record<string, {
+                default?: any;
+                autoincrement?: boolean | undefined;
+                name: string;
+                type: string;
+                primaryKey: boolean;
+                notNull: boolean;
+            }>;
+            indexes: Record<string, {
+                where?: string | undefined;
+                name: string;
+                columns: string[];
+                isUnique: boolean;
+            }>;
+            foreignKeys: Record<string, {
+                onUpdate?: string | undefined;
+                onDelete?: string | undefined;
+                name: string;
+                tableFrom: string;
+                columnsFrom: string[];
+                tableTo: string;
+                columnsTo: string[];
+            }>;
+            compositePrimaryKeys: Record<string, {
+                name: string;
+                columns: string[];
+            }>;
+            uniqueConstraints: Record<string, {
+                name: string;
+                columns: string[];
+            }>;
+        }>;
+        _meta: {
+            columns: Record<string, string>;
+            tables: Record<string, string>;
+        };
+        enums: {};
+    };
+    ts: string;
+}>;
+export declare const sqlitePushIntrospect: (client: DrizzleDbClient, filters: string[]) => Promise<{
+    schema: {
+        id: string;
+        prevId: string;
+        version: "5";
+        dialect: "sqlite";
+        tables: Record<string, {
+            name: string;
+            columns: Record<string, {
+                default?: any;
+                autoincrement?: boolean | undefined;
+                name: string;
+                type: string;
+                primaryKey: boolean;
+                notNull: boolean;
+            }>;
+            indexes: Record<string, {
+                where?: string | undefined;
+                name: string;
+                columns: string[];
+                isUnique: boolean;
+            }>;
+            foreignKeys: Record<string, {
+                onUpdate?: string | undefined;
+                onDelete?: string | undefined;
+                name: string;
+                tableFrom: string;
+                columnsFrom: string[];
+                tableTo: string;
+                columnsTo: string[];
+            }>;
+            compositePrimaryKeys: Record<string, {
+                name: string;
+                columns: string[];
+            }>;
+            uniqueConstraints: Record<string, {
+                name: string;
+                columns: string[];
+            }>;
+        }>;
+        _meta: {
+            columns: Record<string, string>;
+            tables: Record<string, string>;
+        };
+        enums: {};
+    };
+}>;

package/cli/commands/sqliteUtils.d.ts

@@ -0,0 +1,162 @@
+import { TypeOf } from "zod";
+import { configIntrospectSchema } from "./utils";
+export declare const sqliteConnectionSchema: import("zod").ZodUnion<[import("zod").ZodObject<{
+    driver: import("zod").ZodLiteral<"turso">;
+    dbCredentials: import("zod").ZodObject<{
+        url: import("zod").ZodString;
+        authToken: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        authToken?: string | undefined;
+        url: string;
+    }, {
+        authToken?: string | undefined;
+        url: string;
+    }>;
+}, "strip", import("zod").ZodTypeAny, {
+    driver: "turso";
+    dbCredentials: {
+        authToken?: string | undefined;
+        url: string;
+    };
+}, {
+    driver: "turso";
+    dbCredentials: {
+        authToken?: string | undefined;
+        url: string;
+    };
+}>, import("zod").ZodObject<{
+    driver: import("zod").ZodLiteral<"libsql">;
+    dbCredentials: import("zod").ZodObject<{
+        url: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        url: string;
+    }, {
+        url: string;
+    }>;
+}, "strip", import("zod").ZodTypeAny, {
+    driver: "libsql";
+    dbCredentials: {
+        url: string;
+    };
+}, {
+    driver: "libsql";
+    dbCredentials: {
+        url: string;
+    };
+}>, import("zod").ZodObject<{
+    driver: import("zod").ZodLiteral<"better-sqlite">;
+    dbCredentials: import("zod").ZodObject<{
+        url: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        url: string;
+    }, {
+        url: string;
+    }>;
+}, "strip", import("zod").ZodTypeAny, {
+    driver: "better-sqlite";
+    dbCredentials: {
+        url: string;
+    };
+}, {
+    driver: "better-sqlite";
+    dbCredentials: {
+        url: string;
+    };
+}>]>;
+export declare const sqliteCliConfigSchema: import("zod").ZodIntersection<import("zod").ZodObject<{
+    schema: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString, "many">]>>;
+    out: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+    breakpoints: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    tablesFilter: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString, "many">]>>;
+    schemaFilter: import("zod").ZodDefault<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString, "many">]>>;
+    introspect: import("zod").ZodDefault<import("zod").ZodObject<{
+        casing: import("zod").ZodDefault<import("zod").ZodUnion<[import("zod").ZodLiteral<"camel">, import("zod").ZodLiteral<"preserve">]>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        casing: "camel" | "preserve";
+    }, {
+        casing?: "camel" | "preserve" | undefined;
+    }>>;
+}, "strip", import("zod").ZodTypeAny, {
+    schema?: string | string[] | undefined;
+    tablesFilter?: string | string[] | undefined;
+    out: string;
+    breakpoints: boolean;
+    schemaFilter: string | string[];
+    introspect: {
+        casing: "camel" | "preserve";
+    };
+}, {
+    schema?: string | string[] | undefined;
+    out?: string | undefined;
+    breakpoints?: boolean | undefined;
+    tablesFilter?: string | string[] | undefined;
+    schemaFilter?: string | string[] | undefined;
+    introspect?: {
+        casing?: "camel" | "preserve" | undefined;
+    } | undefined;
+}>, import("zod").ZodUnion<[import("zod").ZodObject<{
+    driver: import("zod").ZodLiteral<"turso">;
+    dbCredentials: import("zod").ZodObject<{
+        url: import("zod").ZodString;
+        authToken: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        authToken?: string | undefined;
+        url: string;
+    }, {
+        authToken?: string | undefined;
+        url: string;
+    }>;
+}, "strip", import("zod").ZodTypeAny, {
+    driver: "turso";
+    dbCredentials: {
+        authToken?: string | undefined;
+        url: string;
+    };
+}, {
+    driver: "turso";
+    dbCredentials: {
+        authToken?: string | undefined;
+        url: string;
+    };
+}>, import("zod").ZodObject<{
+    driver: import("zod").ZodLiteral<"libsql">;
+    dbCredentials: import("zod").ZodObject<{
+        url: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        url: string;
+    }, {
+        url: string;
+    }>;
+}, "strip", import("zod").ZodTypeAny, {
+    driver: "libsql";
+    dbCredentials: {
+        url: string;
+    };
+}, {
+    driver: "libsql";
+    dbCredentials: {
+        url: string;
+    };
+}>, import("zod").ZodObject<{
+    driver: import("zod").ZodLiteral<"better-sqlite">;
+    dbCredentials: import("zod").ZodObject<{
+        url: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        url: string;
+    }, {
+        url: string;
+    }>;
+}, "strip", import("zod").ZodTypeAny, {
+    driver: "better-sqlite";
+    dbCredentials: {
+        url: string;
+    };
+}, {
+    driver: "better-sqlite";
+    dbCredentials: {
+        url: string;
+    };
+}>]>>;
+export type SQLiteCliConfig = TypeOf<typeof sqliteCliConfigSchema>;
+export type SQLiteConnectionConfig = TypeOf<typeof sqliteConnectionSchema>;
+export { configIntrospectSchema };