drizzle-kit 0.20.14-a77266f → 0.20.14-f5f86f6

package/cli/commands/check.d.ts

@@ -0,0 +1,2 @@
+import { Dialect } from "../../schemaValidator";
+export declare const checkHandler: (out: string, dialect: Dialect) => void;

package/cli/commands/drop.d.ts

@@ -0,0 +1,4 @@
+export declare const dropMigration: ({ out, bundle, }: {
+    out: string;
+    bundle?: boolean | undefined;
+}) => Promise<void>;

package/cli/commands/migrate.d.ts

@@ -1,9 +1,9 @@
 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 { 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;
@@ -132,7 +132,7 @@ export declare const prepareMySQLPush: (config: {
             schemas: Record<string, string>;
         };
     };
-} | undefined>;
+}>;
 export declare const prepareSQLitePush: (config: {
     schema: string | string[];
 }, snapshot: SQLiteSchema) => Promise<{
@@ -183,7 +183,7 @@ export declare const prepareSQLitePush: (config: {
         tables: {};
         columns: {};
     } | undefined;
-} | undefined>;
+}>;
 export declare const preparePgPush: (config: {
     schema: string | string[];
 }, snapshot: PgSchema, schemaFilter: string[]) => Promise<{
@@ -243,7 +243,7 @@ export declare const preparePgPush: (config: {
             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<{

package/cli/commands/mysqlPushUtils.d.ts

@@ -1,6 +1,6 @@
 import { DrizzleDbClient } from "src/drivers";
-import { JsonStatement } from "src/jsonStatements";
-import { mysqlSchema } from "src/serializer/mysqlSchema";
+import { JsonStatement } from "../../jsonStatements";
+import { mysqlSchema } from "../../serializer/mysqlSchema";
 import { TypeOf } from "zod";
 export declare const filterStatements: (statements: JsonStatement[], currentSchema: TypeOf<typeof mysqlSchema>, prevSchema: TypeOf<typeof mysqlSchema>) => JsonStatement[];
 export declare const logSuggestionsAndReturn: ({ connection, statements, json2, }: {

package/cli/commands/mysqlUp.d.ts

@@ -1,4 +1,4 @@
-import { MySqlSchema, MySqlSchemaV4 } from "src/serializer/mysqlSchema";
+import { MySqlSchema, MySqlSchemaV4 } from "../../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

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

package/cli/commands/pgIntrospect.d.ts

@@ -1,5 +1,5 @@
 import type { PgConfigIntrospect } from "../validations/pg";
-import type { DrizzleDbClient } from "src/drivers";
+import type { DrizzleDbClient } from "../../drivers";
 export declare const pgSchemas: (client: DrizzleDbClient) => Promise<string[]>;
 export declare const pgPushIntrospect: (connection: {
     client: DrizzleDbClient;

package/cli/commands/pgPushUtils.d.ts

@@ -1,5 +1,5 @@
-import { DrizzleDbClient } from "src/drivers";
-import { JsonStatement } from "src/jsonStatements";
+import { DrizzleDbClient } from "../../drivers";
+import { JsonStatement } from "../../jsonStatements";
 export declare const pgSuggestions: ({ connection, statements, }: {
     statements: JsonStatement[];
     connection: DrizzleDbClient;

package/cli/commands/pgUp.d.ts

@@ -1,4 +1,4 @@
-import { PgSchema, PgSchemaV4 } from "src/serializer/pgSchema";
+import { PgSchema, PgSchemaV4 } from "../../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/push.d.ts

@@ -0,0 +1,6 @@
+import { MySQLPushConfig } from "../validations/mysql";
+import { PgPushConfig } from "../validations/pg";
+import { SQLitePushConfig } from "../validations/sqlite";
+export declare const mysqlPush: (drizzleConfig: MySQLPushConfig, tablesFilter: string[]) => Promise<void>;
+export declare const pgPush: (drizzleConfig: PgPushConfig, tablesFilter: string[]) => Promise<void>;
+export declare const sqlitePush: (drizzleConfig: SQLitePushConfig, tablesFilter: string[]) => Promise<void>;

package/cli/commands/sqlitePushUtils.d.ts

@@ -1,6 +1,6 @@
-import { DrizzleDbClient } from "src/drivers";
-import { JsonStatement } from "src/jsonStatements";
-import { SQLiteSchemaInternal, SQLiteSchemaSquashed } from "src/serializer/sqliteSchema";
+import { DrizzleDbClient } from "../../drivers";
+import { JsonStatement } from "../../jsonStatements";
+import { SQLiteSchemaInternal, SQLiteSchemaSquashed } from "../../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;

package/cli/commands/sqliteUp.d.ts

@@ -0,0 +1,2 @@
+export declare const upSqliteHandler: (out: string) => void;
+export declare const upSqliteHandlerV4: (out: string) => void;

package/cli/commands/upFolders.d.ts

@@ -1,4 +1,4 @@
-import { Dialect } from "src/schemaValidator";
+import { Dialect } from "../../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[];

package/cli/commands/utils.d.ts

@@ -1,4 +1,8 @@
 import { TypeOf } from "zod";
+import { CliParamsPush } from "..";
+import { MySQLPushConfig } from "../validations/mysql";
+import { PgPushConfig } from "../validations/pg";
+import { SQLitePushConfig } from "../validations/sqlite";
 export declare const safeRegister: () => Promise<{
     unregister: () => void;
 }>;
@@ -16,6 +20,11 @@ export declare const prepareGenerateConfig: (options: {
     breakpoints: boolean;
     custom: boolean;
 }) => Promise<GenerateConfig>;
+export declare const preparePushConfig: (options: CliParamsPush) => Promise<{
+    config: MySQLPushConfig | PgPushConfig | SQLitePushConfig;
+    schemaFiles: string[];
+    tablesFilter: string[];
+}>;
 export declare const assertOutFolder: (it: {
     config?: string;
 } | {
@@ -38,8 +47,8 @@ export declare const configCommonSchema: import("zod").ZodObject<{
     schemaFilter: string | string[];
 }, {
     out?: string | undefined;
-    breakpoints?: boolean | undefined;
     driver?: "turso" | "better-sqlite" | "libsql" | "d1" | "pg" | "mysql2" | "expo" | undefined;
+    breakpoints?: boolean | undefined;
     tablesFilter?: string | string[] | undefined;
     schemaFilter?: string | string[] | undefined;
     schema: string | string[];
@@ -181,8 +190,8 @@ export declare const mySqlCliConfigSchema: import("zod").ZodIntersection<import(
     schemaFilter: string | string[];
 }, {
     out?: string | undefined;
-    breakpoints?: boolean | undefined;
     driver?: "turso" | "better-sqlite" | "libsql" | "d1" | "pg" | "mysql2" | "expo" | undefined;
+    breakpoints?: boolean | undefined;
     tablesFilter?: string | string[] | undefined;
     schemaFilter?: string | string[] | undefined;
     schema: string | string[];

package/cli/index.d.ts

@@ -0,0 +1,71 @@
+import { TypeOf } from "zod";
+import "../@types/utils";
+import "dotenv/config";
+declare const cliParamsPush: import("zod").ZodObject<{
+    config: import("zod").ZodOptional<import("zod").ZodString>;
+    dialect: import("zod").ZodEnum<["pg", "mysql", "sqlite"]>;
+    schema: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString, "many">]>>;
+    tablesFilter: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString, "many">]>>;
+    driver: import("zod").ZodString;
+    connectionString: import("zod").ZodOptional<import("zod").ZodString>;
+    host: import("zod").ZodOptional<import("zod").ZodString>;
+    port: import("zod").ZodOptional<import("zod").ZodString>;
+    user: import("zod").ZodOptional<import("zod").ZodString>;
+    password: import("zod").ZodOptional<import("zod").ZodString>;
+    database: import("zod").ZodOptional<import("zod").ZodString>;
+    ssl: import("zod").ZodOptional<import("zod").ZodString>;
+    uri: import("zod").ZodOptional<import("zod").ZodString>;
+    authToken: import("zod").ZodOptional<import("zod").ZodString>;
+    verbose: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    strict: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, "strict", import("zod").ZodTypeAny, {
+    schema?: string | string[] | undefined;
+    authToken?: string | undefined;
+    tablesFilter?: string | string[] | undefined;
+    config?: string | undefined;
+    host?: string | undefined;
+    port?: string | undefined;
+    user?: string | undefined;
+    password?: string | undefined;
+    database?: string | undefined;
+    ssl?: string | undefined;
+    connectionString?: string | undefined;
+    uri?: string | undefined;
+    strict: boolean;
+    dialect: "pg" | "mysql" | "sqlite";
+    driver: string;
+    verbose: boolean;
+}, {
+    strict?: boolean | undefined;
+    schema?: string | string[] | undefined;
+    authToken?: string | undefined;
+    tablesFilter?: string | string[] | undefined;
+    config?: string | undefined;
+    verbose?: boolean | undefined;
+    host?: string | undefined;
+    port?: string | undefined;
+    user?: string | undefined;
+    password?: string | undefined;
+    database?: string | undefined;
+    ssl?: string | undefined;
+    connectionString?: string | undefined;
+    uri?: string | undefined;
+    dialect: "pg" | "mysql" | "sqlite";
+    driver: string;
+}>;
+export type CliParamsPush = TypeOf<typeof cliParamsPush>;
+export declare const checkSchema: import("zod").ZodObject<{
+    out: import("zod").ZodOptional<import("zod").ZodString>;
+    config: import("zod").ZodOptional<import("zod").ZodString>;
+    driver: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strict", import("zod").ZodTypeAny, {
+    out?: string | undefined;
+    driver?: string | undefined;
+    config?: string | undefined;
+}, {
+    out?: string | undefined;
+    driver?: string | undefined;
+    config?: string | undefined;
+}>;
+export type CheckConfig = TypeOf<typeof checkSchema>;
+export {};

package/cli/utils.d.ts

@@ -0,0 +1,12 @@
+export declare const assertExists: (it?: any) => void;
+export declare const assertStudioNodeVersion: () => void;
+export declare const assertPackages: (...pkgs: string[]) => Promise<void>;
+export declare const assertEitherPackage: (...pkgs: string[]) => Promise<string[]>;
+export declare const assertOrmCoreVersion: () => Promise<void>;
+export declare const ormCoreVersions: () => Promise<{
+    compatibilityVersion: number;
+    npmVersion: string;
+} | {
+    compatibilityVersion?: undefined;
+    npmVersion?: undefined;
+}>;

package/cli/validations/common.d.ts

@@ -3,7 +3,7 @@ export type CollusionCheckOutput = {
     message?: string;
     action: "config" | "cli" | "error";
 };
-export type Commands = "push:sqlite" | "introspect:sqlite" | "introspect:pg" | "generate:pg" | "generate:sqlite" | "generate:mysql" | "check:pg" | "check:mysql" | "check:sqlite" | "up:pg" | "up:mysql" | "up:sqlite" | "drop" | "introspect:mysql" | "push:mysql" | "push:pg";
+export type Commands = "push:sqlite" | "introspect:sqlite" | "introspect:pg" | "generate" | "check:pg" | "check:mysql" | "check:sqlite" | "up:pg" | "up:mysql" | "up:sqlite" | "drop" | "introspect:mysql" | "push:mysql" | "push:pg";
 /**
  * This function checks an input from a user and if there are any params together with config path - return true
  * @param options - user input

package/cli/validations/sqlite.d.ts

@@ -0,0 +1,220 @@
+import { TypeOf } from "zod";
+import { SQLiteCliConfig } from "../commands/sqliteUtils";
+export declare const sqliteConnectionCli: import("zod").ZodUnion<[import("zod").ZodObject<{
+    driver: import("zod").ZodLiteral<"turso">;
+    url: import("zod").ZodString;
+    authToken: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    url: string;
+    driver: "turso";
+    authToken: string;
+}, {
+    url: string;
+    driver: "turso";
+    authToken: string;
+}>, import("zod").ZodObject<{
+    driver: import("zod").ZodLiteral<"better-sqlite">;
+    url: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    url: string;
+    driver: "better-sqlite";
+}, {
+    url: string;
+    driver: "better-sqlite";
+}>, import("zod").ZodObject<{
+    driver: import("zod").ZodLiteral<"libsql">;
+    url: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    url: string;
+    driver: "libsql";
+}, {
+    url: string;
+    driver: "libsql";
+}>]>;
+export declare const sqliteCliIntrospectParams: 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">]>>;
+    introspectCasing: import("zod").ZodDefault<import("zod").ZodUnion<[import("zod").ZodLiteral<"camel">, import("zod").ZodLiteral<"preserve">]>>;
+}, "strip", import("zod").ZodTypeAny, {
+    schema?: string | string[] | undefined;
+    tablesFilter?: string | string[] | undefined;
+    out: string;
+    breakpoints: boolean;
+    schemaFilter: string | string[];
+    introspectCasing: "camel" | "preserve";
+}, {
+    schema?: string | string[] | undefined;
+    out?: string | undefined;
+    breakpoints?: boolean | undefined;
+    tablesFilter?: string | string[] | undefined;
+    schemaFilter?: string | string[] | undefined;
+    introspectCasing?: "camel" | "preserve" | undefined;
+}>, import("zod").ZodUnion<[import("zod").ZodObject<{
+    driver: import("zod").ZodLiteral<"turso">;
+    url: import("zod").ZodString;
+    authToken: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    url: string;
+    driver: "turso";
+    authToken: string;
+}, {
+    url: string;
+    driver: "turso";
+    authToken: string;
+}>, import("zod").ZodObject<{
+    driver: import("zod").ZodLiteral<"better-sqlite">;
+    url: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    url: string;
+    driver: "better-sqlite";
+}, {
+    url: string;
+    driver: "better-sqlite";
+}>, import("zod").ZodObject<{
+    driver: import("zod").ZodLiteral<"libsql">;
+    url: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    url: string;
+    driver: "libsql";
+}, {
+    url: string;
+    driver: "libsql";
+}>]>>;
+export declare const sqliteCliPushParams: import("zod").ZodIntersection<import("zod").ZodObject<{
+    schema: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString, "many">]>;
+    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">]>>;
+    verbose: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    strict: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, "strip", import("zod").ZodTypeAny, {
+    tablesFilter?: string | string[] | undefined;
+    strict: boolean;
+    schema: string | string[];
+    schemaFilter: string | string[];
+    verbose: boolean;
+}, {
+    strict?: boolean | undefined;
+    tablesFilter?: string | string[] | undefined;
+    schemaFilter?: string | string[] | undefined;
+    verbose?: boolean | undefined;
+    schema: string | string[];
+}>, import("zod").ZodUnion<[import("zod").ZodObject<{
+    driver: import("zod").ZodLiteral<"turso">;
+    url: import("zod").ZodString;
+    authToken: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    url: string;
+    driver: "turso";
+    authToken: string;
+}, {
+    url: string;
+    driver: "turso";
+    authToken: string;
+}>, import("zod").ZodObject<{
+    driver: import("zod").ZodLiteral<"better-sqlite">;
+    url: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    url: string;
+    driver: "better-sqlite";
+}, {
+    url: string;
+    driver: "better-sqlite";
+}>, import("zod").ZodObject<{
+    driver: import("zod").ZodLiteral<"libsql">;
+    url: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    url: string;
+    driver: "libsql";
+}, {
+    url: string;
+    driver: "libsql";
+}>]>>;
+export declare const sqliteConfigPushParams: import("zod").ZodIntersection<import("zod").ZodObject<{
+    schema: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString, "many">]>;
+    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">]>>;
+    verbose: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    strict: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, "strip", import("zod").ZodTypeAny, {
+    tablesFilter?: string | string[] | undefined;
+    strict: boolean;
+    schema: string | string[];
+    schemaFilter: string | string[];
+    verbose: boolean;
+}, {
+    strict?: boolean | undefined;
+    tablesFilter?: string | string[] | undefined;
+    schemaFilter?: string | string[] | undefined;
+    verbose?: boolean | undefined;
+    schema: string | string[];
+}>, 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 SQLitePushConfig = TypeOf<typeof sqliteConfigPushParams>;
+export declare const printConfigConnectionIssues: (options: any) => void;
+export declare const validateIntrospect: (options: Record<string, any>) => Promise<SQLiteCliConfig>;
+export declare const validatePush: (options: Record<string, unknown>) => Promise<SQLitePushConfig>;
+export declare const validateGenerate: () => void;