drizzle-kit 0.20.1 → 0.20.2-8e648e0

package/cli/commands/mysqlIntrospect.d.ts

@@ -0,0 +1,114 @@
+import { MySQLConfigIntrospect, MySQLConnectionConfig } from "../validations/mysql";
+import { DrizzleDbClient, MySQL2Client } from "src/drivers";
+export declare const connectToMySQL: (config: MySQLConnectionConfig) => Promise<{
+    client: MySQL2Client;
+    databaseName: string;
+}>;
+export declare const mysqlIntrospect: (config: MySQLConfigIntrospect, filters: string[]) => Promise<{
+    schema: {
+        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>;
+        };
+    };
+    ts: string;
+}>;
+export declare const mysqlPushIntrospect: (connection: {
+    client: DrizzleDbClient;
+    databaseName: string;
+}, filters: string[]) => Promise<{
+    schema: {
+        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>;
+        };
+    };
+}>;

package/cli/commands/mysqlPushUtils.d.ts

@@ -0,0 +1,17 @@
+import { DrizzleDbClient } from "src/drivers";
+import { JsonStatement } from "src/jsonStatements";
+import { mysqlSchema } from "src/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, }: {
+    statements: JsonStatement[];
+    connection: DrizzleDbClient;
+}) => Promise<{
+    statementsToExecute: string[];
+    shouldAskForApprove: boolean;
+    infoToPrint: string[];
+    columnsToRemove: string[];
+    schemasToRemove: string[];
+    tablesToTruncate: string[];
+    tablesToRemove: string[];
+}>;

package/cli/commands/sqlitePushUtils.d.ts

@@ -0,0 +1,21 @@
+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, statements, json1, json2, meta, }: {
+    statements: JsonStatement[];
+    connection: DrizzleDbClient;
+    json1: SQLiteSchemaSquashed;
+    json2: SQLiteSchemaSquashed;
+    meta: SQLiteSchemaInternal["_meta"];
+}) => Promise<{
+    statementsToExecute: string[];
+    shouldAskForApprove: boolean;
+    infoToPrint: string[];
+    columnsToRemove: string[];
+    schemasToRemove: string[];
+    tablesToTruncate: string[];
+    tablesToRemove: string[];
+}>;

package/drivers/index.d.ts

@@ -1,4 +1,6 @@
 import type { Client } from "@libsql/client";
+import { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
+import { MySql2Database } from "drizzle-orm/mysql2";
 import type { PgDatabase } from "drizzle-orm/pg-core";
 import type { Client as PgClient } from "pg";
 export declare abstract class DrizzleDbClient<T = any> {
@@ -11,10 +13,22 @@ export declare class DrizzleORMPgClient extends DrizzleDbClient<PgDatabase<any>>
     query<K = any>(query: string, values?: any[] | undefined): Promise<K[]>;
     run(query: string): Promise<void>;
 }
+export declare class DrizzleORMMySQLClient extends DrizzleDbClient<MySql2Database<any>> {
+    query<K = any>(query: string, values?: any[] | undefined): Promise<K[]>;
+    run(query: string): Promise<void>;
+}
+export declare class DrizzleORMSQLiteClient extends DrizzleDbClient<BetterSQLite3Database<any>> {
+    query<K = any>(query: string, values?: any[] | undefined): Promise<K[]>;
+    run(query: string): Promise<void>;
+}
 export declare class BetterSqlite extends DrizzleDbClient {
     run(query: string): Promise<void>;
     query(query: string): Promise<any[]>;
 }
+export declare class MySQL2Client extends DrizzleDbClient {
+    run(query: string): Promise<void>;
+    query(query: string): Promise<any>;
+}
 export declare class TursoSqlite extends DrizzleDbClient<Client> {
     run(query: string): Promise<void>;
     query(query: string): Promise<any[]>;

package/mysql-introspect.d.ts

@@ -0,0 +1,4 @@
+import "./@types/utils";
+import { ConfigIntrospectCasing } from "./cli/commands/utils";
+import { MySqlSchema } from "./serializer/mysqlSchema";
+export declare const schemaToTypeScript: (schema: MySqlSchema, casing: ConfigIntrospectCasing["casing"]) => string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drizzle-kit",
-  "version": "0.20.1",
+  "version": "0.20.2-8e648e0",
   "repository": "https://github.com/drizzle-team/drizzle-kit-mirror",
   "author": "Drizzle Team",
   "license": "MIT",

package/serializer/mysqlImports.d.ts

@@ -1,4 +1,9 @@
 import { AnyMySqlTable, MySqlSchema } from "drizzle-orm/mysql-core";
+export declare const prepareFromExports: (exports: Record<string, unknown>) => {
+    tables: AnyMySqlTable<{}>[];
+    enums: any[];
+    schemas: MySqlSchema<string>[];
+};
 export declare const prepareFromMySqlImports: (imports: string[]) => Promise<{
     tables: AnyMySqlTable<{}>[];
     enums: any[];

package/serializer/mysqlSerializer.d.ts

@@ -1,7 +1,7 @@
 import { AnyMySqlTable, MySqlSchema } from "drizzle-orm/mysql-core";
 import { MySqlSchemaInternal } from "src/serializer/mysqlSchema";
-import { Connection } from "mysql2/promise";
 import { IntrospectStage, IntrospectStatus } from "src/cli/views";
+import { DrizzleDbClient } from "src/drivers";
 export declare const indexName: (tableName: string, columns: string[]) => string;
 export declare const generateMySqlSnapshot: (tables: AnyMySqlTable[], enums: any[], mysqlSchemas: MySqlSchema[]) => MySqlSchemaInternal;
-export declare const fromDatabase: (db: Connection, inputSchema: string, tablesFilter?: (table: string) => boolean, progressCallback?: ((stage: IntrospectStage, count: number, status: IntrospectStatus) => void) | undefined) => Promise<MySqlSchemaInternal>;
+export declare const fromDatabase: (db: DrizzleDbClient, inputSchema: string, tablesFilter?: (table: string) => boolean, progressCallback?: ((stage: IntrospectStage, count: number, status: IntrospectStatus) => void) | undefined) => Promise<MySqlSchemaInternal>;

package/serializer/sqliteImports.d.ts

@@ -1,4 +1,8 @@
 import { AnySQLiteTable } from "drizzle-orm/sqlite-core";
+export declare const prepareFromExports: (exports: Record<string, unknown>) => {
+    tables: AnySQLiteTable<{}>[];
+    enums: any[];
+};
 export declare const prepareFromSqliteImports: (imports: string[]) => Promise<{
     tables: AnySQLiteTable<{}>[];
     enums: any[];

package/utils.d.ts

@@ -2,7 +2,11 @@ import { Dialect } from "./schemaValidator";
 import { NamedWithSchema } from "./cli/commands/migrate";
 import { PgDatabase } from "drizzle-orm/pg-core";
 import { PgSchema as PgSchemaKit } from "./serializer/pgSchema";
+import { SQLiteSchema as SQLiteSchemaKit } from "./serializer/sqliteSchema";
+import { MySqlSchema as MySQLSchemaKit } from "./serializer/mysqlSchema";
 import { DbConnection } from ".";
+import { MySql2Database } from "drizzle-orm/mysql2";
+import { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
 export declare const assertV1OutFolder: (out: string, dialect: Dialect | "{dialect}") => void;
 export type Journal = {
     version: string;
@@ -200,6 +204,8 @@ export declare const statementsForDiffs: (in1: any, in2: any) => Promise<{
     } | undefined;
 }>;
 export type DrizzleSnapshotJSON = PgSchemaKit;
+export type DrizzleSQLiteSnapshotJSON = SQLiteSchemaKit;
+export type DrizzleMySQLSnapshotJSON = MySQLSchemaKit;
 export declare const generateDrizzleJson: (imports: Record<string, unknown>, prevId?: string) => PgSchemaKit;
 export declare const generateMigration: (prev: DrizzleSnapshotJSON, cur: DrizzleSnapshotJSON) => Promise<string[]>;
 export declare const pushSchema: (imports: Record<string, unknown>, db: PgDatabase<any>) => Promise<{
@@ -209,3 +215,19 @@ export declare const pushSchema: (imports: Record<string, unknown>, db: PgDataba
     apply: () => Promise<void>;
 }>;
 export declare const prepareFrom: (connection: DbConnection) => Promise<Record<string, any>>;
+export declare const generateSQLiteDrizzleJson: (imports: Record<string, unknown>, prevId?: string) => Promise<SQLiteSchemaKit>;
+export declare const generateSQLiteMigration: (prev: DrizzleSQLiteSnapshotJSON, cur: DrizzleSQLiteSnapshotJSON) => Promise<string[]>;
+export declare const pushSQLiteSchema: (imports: Record<string, unknown>, db: BetterSQLite3Database<any>) => Promise<{
+    hasDataLoss: boolean;
+    warnings: string[];
+    statementsToExecute: string[];
+    apply: () => Promise<void>;
+}>;
+export declare const generateMySQLDrizzleJson: (imports: Record<string, unknown>, prevId?: string) => Promise<MySQLSchemaKit>;
+export declare const generateMySQLMigration: (prev: DrizzleMySQLSnapshotJSON, cur: DrizzleMySQLSnapshotJSON) => Promise<string[]>;
+export declare const pushMySQLSchema: (imports: Record<string, unknown>, db: MySql2Database<any>, databaseName: string) => Promise<{
+    hasDataLoss: boolean;
+    warnings: string[];
+    statementsToExecute: string[];
+    apply: () => Promise<void>;
+}>;