drizzle-kit 0.20.17-4e262b7 → 0.20.17-7776aba

package/cli/commands/pgIntrospect.d.ts

@@ -1,18 +1,81 @@
-import type { DB } from "../../utils";
-export declare const pgPushIntrospect: (db: DB, filters: string[], schemaFilters: string[]) => Promise<{
+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;
+                schemaTo?: 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;
-                typeSchema?: string | undefined;
                 uniqueName?: string | undefined;
                 nullsNotDistinct?: boolean | undefined;
+                name: string;
+                type: string;
+                primaryKey: boolean;
+                notNull: boolean;
             }>;
             indexes: Record<string, {
                 name: string;
@@ -20,14 +83,14 @@ export declare const pgPushIntrospect: (db: DB, filters: string[], schemaFilters
                 isUnique: boolean;
             }>;
             foreignKeys: Record<string, {
+                onUpdate?: string | undefined;
+                onDelete?: string | undefined;
+                schemaTo?: string | undefined;
                 name: string;
                 tableFrom: string;
                 columnsFrom: string[];
                 tableTo: string;
                 columnsTo: string[];
-                onUpdate?: string | undefined;
-                onDelete?: string | undefined;
-                schemaTo?: string | undefined;
             }>;
             schema: string;
             compositePrimaryKeys: Record<string, {
@@ -40,10 +103,6 @@ export declare const pgPushIntrospect: (db: DB, filters: string[], schemaFilters
                 nullsNotDistinct: boolean;
             }>;
         }>;
-        id: string;
-        prevId: string;
-        version: "6";
-        dialect: "pg";
         schemas: Record<string, string>;
         _meta: {
             columns: Record<string, string>;
@@ -52,8 +111,13 @@ export declare const pgPushIntrospect: (db: DB, filters: string[], schemaFilters
         };
         enums: Record<string, {
             name: string;
-            values: string[];
-            schema: string;
+            values: Record<string, string>;
         }>;
     };
+    ts: {
+        file: string;
+        imports: string;
+        decalrations: string;
+        schemaEntry: string;
+    };
 }>;

package/cli/commands/pgPushUtils.d.ts

@@ -1,6 +1,9 @@
-import type { DB } from "../../utils";
-import type { JsonStatement } from "../../jsonStatements";
-export declare const pgSuggestions: (db: DB, statements: JsonStatement[]) => Promise<{
+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[];

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

@@ -1,47 +1,50 @@
-import type { SqliteCredentials } from "../validations/sqlite";
-import type { SQLiteDB } from "../../utils";
-import { Casing } from "../validations/common";
-export declare const connectToSQLite: (credentials: SqliteCredentials) => Promise<SQLiteDB>;
-export declare const sqliteIntrospect: (credentials: SqliteCredentials, filters: string[], casing: Casing) => Promise<{
+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;
-                default?: any;
-                autoincrement?: boolean | undefined;
             }>;
             indexes: Record<string, {
+                where?: string | undefined;
                 name: string;
                 columns: string[];
                 isUnique: boolean;
-                where?: string | undefined;
             }>;
             foreignKeys: Record<string, {
+                onUpdate?: string | undefined;
+                onDelete?: string | undefined;
                 name: string;
                 tableFrom: string;
                 columnsFrom: string[];
                 tableTo: string;
                 columnsTo: string[];
-                onUpdate?: string | undefined;
-                onDelete?: string | undefined;
             }>;
             compositePrimaryKeys: Record<string, {
-                columns: string[];
                 name?: string | undefined;
+                columns: string[];
             }>;
             uniqueConstraints: Record<string, {
                 name: string;
                 columns: string[];
             }>;
         }>;
-        id: string;
-        prevId: string;
-        version: "5";
-        dialect: "sqlite";
         _meta: {
             columns: Record<string, string>;
             tables: Record<string, string>;
@@ -55,46 +58,46 @@ export declare const sqliteIntrospect: (credentials: SqliteCredentials, filters:
         schemaEntry: string;
     };
 }>;
-export declare const sqlitePushIntrospect: (db: SQLiteDB, filters: string[]) => Promise<{
+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;
-                default?: any;
-                autoincrement?: boolean | undefined;
             }>;
             indexes: Record<string, {
+                where?: string | undefined;
                 name: string;
                 columns: string[];
                 isUnique: boolean;
-                where?: string | undefined;
             }>;
             foreignKeys: Record<string, {
+                onUpdate?: string | undefined;
+                onDelete?: string | undefined;
                 name: string;
                 tableFrom: string;
                 columnsFrom: string[];
                 tableTo: string;
                 columnsTo: string[];
-                onUpdate?: string | undefined;
-                onDelete?: string | undefined;
             }>;
             compositePrimaryKeys: Record<string, {
-                columns: string[];
                 name?: string | undefined;
+                columns: string[];
             }>;
             uniqueConstraints: Record<string, {
                 name: string;
                 columns: string[];
             }>;
         }>;
-        id: string;
-        prevId: string;
-        version: "5";
-        dialect: "sqlite";
         _meta: {
             columns: Record<string, string>;
             tables: Record<string, string>;

package/cli/commands/sqlitePushUtils.d.ts

@@ -1,10 +1,16 @@
-import { SQLiteSchemaInternal, SQLiteSchemaSquashed } from "../../serializer/sqliteSchema";
-import type { JsonStatement } from "../../jsonStatements";
-import type { DB } from "../../utils";
+import { DrizzleDbClient } from "src/drivers";
+import { JsonStatement } from "src/jsonStatements";
+import { SQLiteSchemaInternal, SQLiteSchemaSquashed } from "src/serializer/sqliteSchema";
 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: DB, statements: JsonStatement[], json1: SQLiteSchemaSquashed, json2: SQLiteSchemaSquashed, meta: SQLiteSchemaInternal["_meta"]) => Promise<{
+export declare const logSuggestionsAndReturn: ({ connection, statements, json1, json2, meta, }: {
+    statements: JsonStatement[];
+    connection: DrizzleDbClient;
+    json1: SQLiteSchemaSquashed;
+    json2: SQLiteSchemaSquashed;
+    meta: SQLiteSchemaInternal["_meta"];
+}) => Promise<{
     statementsToExecute: string[];
     shouldAskForApprove: boolean;
     infoToPrint: string[];

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 };

package/cli/commands/upFolders.d.ts

@@ -0,0 +1,27 @@
+import { Dialect } from "src/schemaValidator";
+import { Named, NamedWithSchema } from "./migrate";
+export declare const resolveSchemas: <T extends Named>(missingSchemas: T[], newSchemas: T[], predicate: (leftMissing: T[], created: T) => T | undefined) => {
+    created: T[];
+    renamed: {
+        from: T;
+        to: T;
+    }[];
+    deleted: T[];
+};
+export declare const resolveTables: <T extends NamedWithSchema>(missingTables: T[], newTables: T[], resolver: (leftMissing: T[], created: T) => T | undefined) => {
+    created: T[];
+    renamed: {
+        from: T;
+        to: T;
+    }[];
+    deleted: T[];
+};
+export declare const resolveColumns: <T extends Named>(missingColumns: T[], newColumns: T[], predicate: (leftMissing: T[], created: T) => T | undefined) => {
+    created: T[];
+    renamed: {
+        from: T;
+        to: T;
+    }[];
+    deleted: T[];
+};
+export declare const upgradeFolders: (dialect: Dialect, out: string) => void;