drizzle-kit 0.20.17-cab52ad → 0.20.17-d71f2ee

package/cli/commands/migrate.d.ts

@@ -0,0 +1,287 @@
+import { Column, ColumnsResolverInput, ColumnsResolverOutput, Enum, ResolverInput, ResolverOutput, ResolverOutputWithMoved, Table } from "../../snapshotsDiffer";
+import type { CommonSchema } from "../../schemaValidator";
+import { PgSchema } from "../../serializer/pgSchema";
+import { SQLiteSchema } from "../../serializer/sqliteSchema";
+import { MySqlSchema } from "../../serializer/mysqlSchema";
+import { Journal } from "../../utils";
+import { GenerateConfig } from "./utils";
+export type Named = {
+    name: string;
+};
+export type NamedWithSchema = {
+    name: string;
+    schema: string;
+};
+export declare const schemasResolver: (input: ResolverInput<Table>) => Promise<ResolverOutput<Table>>;
+export declare const tablesResolver: (input: ResolverInput<Table>) => Promise<ResolverOutputWithMoved<Table>>;
+export declare const enumsResolver: (input: ResolverInput<Enum>) => Promise<ResolverOutputWithMoved<Enum>>;
+export declare const columnsResolver: (input: ColumnsResolverInput<Column>) => Promise<ColumnsResolverOutput<Column>>;
+export declare const prepareAndMigratePg: (config: GenerateConfig) => Promise<void>;
+export declare const preparePgPush: (schemaPath: string | string[], snapshot: PgSchema, schemaFilter: string[]) => Promise<{
+    sqlStatements: string[];
+    statements: import("../../jsonStatements").JsonStatement[];
+    squashedPrev: {
+        tables: Record<string, {
+            name: string;
+            columns: Record<string, {
+                name: string;
+                type: string;
+                primaryKey: boolean;
+                notNull: boolean;
+                isUnique?: any;
+                default?: any;
+                typeSchema?: string | undefined;
+                uniqueName?: string | undefined;
+                nullsNotDistinct?: boolean | undefined;
+            }>;
+            indexes: Record<string, string>;
+            foreignKeys: Record<string, string>;
+            schema: string;
+            compositePrimaryKeys: Record<string, string>;
+            uniqueConstraints: Record<string, string>;
+        }>;
+        version: "6";
+        dialect: "postgresql";
+        schemas: Record<string, string>;
+        enums: Record<string, {
+            name: string;
+            values: string[];
+            schema: string;
+        }>;
+    };
+    squashedCur: {
+        tables: Record<string, {
+            name: string;
+            columns: Record<string, {
+                name: string;
+                type: string;
+                primaryKey: boolean;
+                notNull: boolean;
+                isUnique?: any;
+                default?: any;
+                typeSchema?: string | undefined;
+                uniqueName?: string | undefined;
+                nullsNotDistinct?: boolean | undefined;
+            }>;
+            indexes: Record<string, string>;
+            foreignKeys: Record<string, string>;
+            schema: string;
+            compositePrimaryKeys: Record<string, string>;
+            uniqueConstraints: Record<string, string>;
+        }>;
+        version: "6";
+        dialect: "postgresql";
+        schemas: Record<string, string>;
+        enums: Record<string, {
+            name: string;
+            values: string[];
+            schema: string;
+        }>;
+    };
+}>;
+export declare const prepareMySQLPush: (schemaPath: string | string[], snapshot: MySqlSchema) => Promise<{
+    sqlStatements: string[];
+    statements: import("../../jsonStatements").JsonStatement[];
+    validatedCur: {
+        tables: Record<string, {
+            name: string;
+            columns: Record<string, {
+                name: string;
+                type: string;
+                primaryKey: boolean;
+                notNull: boolean;
+                default?: any;
+                onUpdate?: any;
+                autoincrement?: boolean | undefined;
+            }>;
+            indexes: Record<string, {
+                name: string;
+                columns: string[];
+                isUnique: boolean;
+                using?: "btree" | "hash" | undefined;
+                algorithm?: "default" | "inplace" | "copy" | undefined;
+                lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            }>;
+            foreignKeys: Record<string, {
+                name: string;
+                tableFrom: string;
+                columnsFrom: string[];
+                tableTo: string;
+                columnsTo: string[];
+                onUpdate?: string | undefined;
+                onDelete?: string | undefined;
+            }>;
+            compositePrimaryKeys: Record<string, {
+                name: string;
+                columns: string[];
+            }>;
+            uniqueConstraints: Record<string, {
+                name: string;
+                columns: string[];
+            }>;
+        }>;
+        id: string;
+        prevId: string;
+        version: "5";
+        dialect: "mysql";
+        _meta: {
+            columns: Record<string, string>;
+            tables: Record<string, string>;
+        };
+        internal?: {
+            tables: Record<string, {
+                columns: Record<string, {
+                    isDefaultAnExpression?: boolean | undefined;
+                } | undefined>;
+            } | undefined>;
+        } | undefined;
+    };
+    validatedPrev: {
+        tables: Record<string, {
+            name: string;
+            columns: Record<string, {
+                name: string;
+                type: string;
+                primaryKey: boolean;
+                notNull: boolean;
+                default?: any;
+                onUpdate?: any;
+                autoincrement?: boolean | undefined;
+            }>;
+            indexes: Record<string, {
+                name: string;
+                columns: string[];
+                isUnique: boolean;
+                using?: "btree" | "hash" | undefined;
+                algorithm?: "default" | "inplace" | "copy" | undefined;
+                lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            }>;
+            foreignKeys: Record<string, {
+                name: string;
+                tableFrom: string;
+                columnsFrom: string[];
+                tableTo: string;
+                columnsTo: string[];
+                onUpdate?: string | undefined;
+                onDelete?: string | undefined;
+            }>;
+            compositePrimaryKeys: Record<string, {
+                name: string;
+                columns: string[];
+            }>;
+            uniqueConstraints: Record<string, {
+                name: string;
+                columns: string[];
+            }>;
+        }>;
+        id: string;
+        prevId: string;
+        version: "5";
+        dialect: "mysql";
+        _meta: {
+            columns: Record<string, string>;
+            tables: Record<string, string>;
+        };
+        internal?: {
+            tables: Record<string, {
+                columns: Record<string, {
+                    isDefaultAnExpression?: boolean | undefined;
+                } | undefined>;
+            } | undefined>;
+        } | undefined;
+    };
+}>;
+export declare const prepareAndMigrateMysql: (config: GenerateConfig) => Promise<void>;
+export declare const prepareAndMigrateSqlite: (config: GenerateConfig) => Promise<void>;
+export declare const prepareSQLitePush: (schemaPath: string | string[], snapshot: SQLiteSchema) => Promise<{
+    sqlStatements: string[];
+    statements: import("../../jsonStatements").JsonStatement[];
+    squashedPrev: {
+        tables: Record<string, {
+            name: string;
+            columns: Record<string, {
+                name: string;
+                type: string;
+                primaryKey: boolean;
+                notNull: boolean;
+                default?: any;
+                autoincrement?: boolean | undefined;
+            }>;
+            indexes: Record<string, string>;
+            foreignKeys: Record<string, string>;
+            compositePrimaryKeys: Record<string, string>;
+            uniqueConstraints: Record<string, string>;
+        }>;
+        version: "5";
+        dialect: "sqlite";
+        enums?: any;
+    };
+    squashedCur: {
+        tables: Record<string, {
+            name: string;
+            columns: Record<string, {
+                name: string;
+                type: string;
+                primaryKey: boolean;
+                notNull: boolean;
+                default?: any;
+                autoincrement?: boolean | undefined;
+            }>;
+            indexes: Record<string, string>;
+            foreignKeys: Record<string, string>;
+            compositePrimaryKeys: Record<string, string>;
+            uniqueConstraints: Record<string, string>;
+        }>;
+        version: "5";
+        dialect: "sqlite";
+        enums?: any;
+    };
+    meta: {
+        schemas: {};
+        tables: {};
+        columns: {};
+    } | undefined;
+}>;
+export declare const promptColumnsConflicts: <T extends Named>(tableName: string, newColumns: T[], missingColumns: T[]) => Promise<{
+    created: T[];
+    renamed: {
+        from: T;
+        to: T;
+    }[];
+    deleted: T[];
+}>;
+export declare const promptNamedWithSchemasConflict: <T extends NamedWithSchema>(newItems: T[], missingItems: T[], entity: "table" | "enum") => Promise<{
+    created: T[];
+    renamed: {
+        from: T;
+        to: T;
+    }[];
+    moved: {
+        name: string;
+        schemaFrom: string;
+        schemaTo: string;
+    }[];
+    deleted: T[];
+}>;
+export declare const promptSchemasConflict: <T extends Named>(newSchemas: T[], missingSchemas: T[]) => Promise<{
+    created: T[];
+    renamed: {
+        from: T;
+        to: T;
+    }[];
+    deleted: T[];
+}>;
+export declare const BREAKPOINT = "--> statement-breakpoint\n";
+export declare const writeResult: ({ cur, sqlStatements, journal, _meta, outFolder, breakpoints, name, bundle, type, }: {
+    cur: CommonSchema;
+    sqlStatements: string[];
+    journal: Journal;
+    _meta?: any;
+    outFolder: string;
+    breakpoints: boolean;
+    name?: string;
+    bundle?: boolean;
+    type?: "introspect" | "custom" | "none";
+}) => void;
+export declare const embeddedMigrations: (journal: Journal) => string;
+export declare const prepareSnapshotFolderName: () => string;

package/cli/commands/mysqlIntrospect.d.ts

@@ -0,0 +1,50 @@
+import type { DB } from "../../utils";
+export declare const mysqlPushIntrospect: (db: DB, databaseName: string, filters: string[]) => Promise<{
+    schema: {
+        tables: Record<string, {
+            name: string;
+            columns: Record<string, {
+                name: string;
+                type: string;
+                primaryKey: boolean;
+                notNull: boolean;
+                default?: any;
+                onUpdate?: any;
+                autoincrement?: boolean | undefined;
+            }>;
+            indexes: Record<string, {
+                name: string;
+                columns: string[];
+                isUnique: boolean;
+                using?: "btree" | "hash" | undefined;
+                algorithm?: "default" | "inplace" | "copy" | undefined;
+                lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            }>;
+            foreignKeys: Record<string, {
+                name: string;
+                tableFrom: string;
+                columnsFrom: string[];
+                tableTo: string;
+                columnsTo: string[];
+                onUpdate?: string | undefined;
+                onDelete?: string | undefined;
+            }>;
+            compositePrimaryKeys: Record<string, {
+                name: string;
+                columns: string[];
+            }>;
+            uniqueConstraints: Record<string, {
+                name: string;
+                columns: string[];
+            }>;
+        }>;
+        id: string;
+        prevId: string;
+        version: "5";
+        dialect: "mysql";
+        _meta: {
+            columns: Record<string, string>;
+            tables: Record<string, string>;
+        };
+    };
+}>;

package/cli/commands/mysqlPushUtils.d.ts

@@ -0,0 +1,14 @@
+import { JsonStatement } from "../../jsonStatements";
+import { mysqlSchema } from "../../serializer/mysqlSchema";
+import { TypeOf } from "zod";
+import type { DB } from "../../utils";
+export declare const filterStatements: (statements: JsonStatement[], currentSchema: TypeOf<typeof mysqlSchema>, prevSchema: TypeOf<typeof mysqlSchema>) => JsonStatement[];
+export declare const logSuggestionsAndReturn: (db: DB, statements: JsonStatement[], json2: TypeOf<typeof mysqlSchema>) => Promise<{
+    statementsToExecute: string[];
+    shouldAskForApprove: boolean;
+    infoToPrint: string[];
+    columnsToRemove: string[];
+    schemasToRemove: string[];
+    tablesToTruncate: string[];
+    tablesToRemove: string[];
+}>;

package/cli/commands/pgIntrospect.d.ts

@@ -0,0 +1,59 @@
+import type { DB } from "../../utils";
+export declare const pgPushIntrospect: (db: DB, filters: string[], schemaFilters: string[]) => Promise<{
+    schema: {
+        tables: Record<string, {
+            name: string;
+            columns: Record<string, {
+                name: string;
+                type: string;
+                primaryKey: boolean;
+                notNull: boolean;
+                isUnique?: any;
+                default?: any;
+                typeSchema?: string | undefined;
+                uniqueName?: string | undefined;
+                nullsNotDistinct?: boolean | undefined;
+            }>;
+            indexes: Record<string, {
+                name: string;
+                columns: string[];
+                isUnique: boolean;
+            }>;
+            foreignKeys: Record<string, {
+                name: string;
+                tableFrom: string;
+                columnsFrom: string[];
+                tableTo: string;
+                columnsTo: string[];
+                onUpdate?: string | undefined;
+                onDelete?: string | undefined;
+                schemaTo?: string | undefined;
+            }>;
+            schema: string;
+            compositePrimaryKeys: Record<string, {
+                name: string;
+                columns: string[];
+            }>;
+            uniqueConstraints: Record<string, {
+                name: string;
+                columns: string[];
+                nullsNotDistinct: boolean;
+            }>;
+        }>;
+        id: string;
+        prevId: string;
+        version: "6";
+        dialect: "postgresql";
+        schemas: Record<string, string>;
+        _meta: {
+            columns: Record<string, string>;
+            tables: Record<string, string>;
+            schemas: Record<string, string>;
+        };
+        enums: Record<string, {
+            name: string;
+            values: string[];
+            schema: string;
+        }>;
+    };
+}>;

package/cli/commands/pgPushUtils.d.ts

@@ -0,0 +1,11 @@
+import type { DB } from "../../utils";
+import type { JsonStatement } from "../../jsonStatements";
+export declare const pgSuggestions: (db: DB, statements: JsonStatement[]) => Promise<{
+    statementsToExecute: string[];
+    shouldAskForApprove: boolean;
+    infoToPrint: string[];
+    columnsToRemove: string[];
+    schemasToRemove: string[];
+    tablesToTruncate: string[];
+    tablesToRemove: string[];
+}>;

package/cli/commands/sqliteIntrospect.d.ts

@@ -0,0 +1,103 @@
+import type { SqliteCredentials } from "../validations/sqlite";
+import type { SQLiteDB } from "../../utils";
+import { Casing } from "../validations/common";
+export declare const sqliteIntrospect: (credentials: SqliteCredentials, filters: string[], casing: Casing) => Promise<{
+    schema: {
+        tables: Record<string, {
+            name: string;
+            columns: Record<string, {
+                name: string;
+                type: string;
+                primaryKey: boolean;
+                notNull: boolean;
+                default?: any;
+                autoincrement?: boolean | undefined;
+            }>;
+            indexes: Record<string, {
+                name: string;
+                columns: string[];
+                isUnique: boolean;
+                where?: string | undefined;
+            }>;
+            foreignKeys: Record<string, {
+                name: string;
+                tableFrom: string;
+                columnsFrom: string[];
+                tableTo: string;
+                columnsTo: string[];
+                onUpdate?: string | undefined;
+                onDelete?: string | undefined;
+            }>;
+            compositePrimaryKeys: Record<string, {
+                columns: string[];
+                name?: string | undefined;
+            }>;
+            uniqueConstraints: Record<string, {
+                name: string;
+                columns: string[];
+            }>;
+        }>;
+        id: string;
+        prevId: string;
+        version: "5";
+        dialect: "sqlite";
+        _meta: {
+            columns: Record<string, string>;
+            tables: Record<string, string>;
+        };
+        enums: {};
+    };
+    ts: {
+        file: string;
+        imports: string;
+        decalrations: string;
+        schemaEntry: string;
+    };
+}>;
+export declare const sqlitePushIntrospect: (db: SQLiteDB, filters: string[]) => Promise<{
+    schema: {
+        tables: Record<string, {
+            name: string;
+            columns: Record<string, {
+                name: string;
+                type: string;
+                primaryKey: boolean;
+                notNull: boolean;
+                default?: any;
+                autoincrement?: boolean | undefined;
+            }>;
+            indexes: Record<string, {
+                name: string;
+                columns: string[];
+                isUnique: boolean;
+                where?: string | undefined;
+            }>;
+            foreignKeys: Record<string, {
+                name: string;
+                tableFrom: string;
+                columnsFrom: string[];
+                tableTo: string;
+                columnsTo: string[];
+                onUpdate?: string | undefined;
+                onDelete?: string | undefined;
+            }>;
+            compositePrimaryKeys: Record<string, {
+                columns: string[];
+                name?: string | undefined;
+            }>;
+            uniqueConstraints: Record<string, {
+                name: string;
+                columns: string[];
+            }>;
+        }>;
+        id: string;
+        prevId: string;
+        version: "5";
+        dialect: "sqlite";
+        _meta: {
+            columns: Record<string, string>;
+            tables: Record<string, string>;
+        };
+        enums: {};
+    };
+}>;

package/cli/commands/sqlitePushUtils.d.ts

@@ -0,0 +1,15 @@
+import { SQLiteSchemaInternal, SQLiteSchemaSquashed } from "../../serializer/sqliteSchema";
+import type { JsonStatement } from "../../jsonStatements";
+import type { SQLiteDB } from "../../utils";
+export declare const _moveDataStatements: (tableName: string, json: SQLiteSchemaSquashed, dataLoss?: boolean) => string[];
+export declare const getOldTableName: (tableName: string, meta: SQLiteSchemaInternal["_meta"]) => string;
+export declare const getNewTableName: (tableName: string, meta: SQLiteSchemaInternal["_meta"]) => string;
+export declare const logSuggestionsAndReturn: (connection: SQLiteDB, statements: JsonStatement[], json1: SQLiteSchemaSquashed, json2: SQLiteSchemaSquashed, meta: SQLiteSchemaInternal["_meta"]) => Promise<{
+    statementsToExecute: string[];
+    shouldAskForApprove: boolean;
+    infoToPrint: string[];
+    columnsToRemove: string[];
+    schemasToRemove: string[];
+    tablesToTruncate: string[];
+    tablesToRemove: string[];
+}>;