drizzle-kit 0.20.0-baf960c → 0.20.0-e4ed989

package/sqlgenerator.d.ts

@@ -0,0 +1,33 @@
+import { JsonCreateIndexStatement, JsonDropIndexStatement, JsonDropTableStatement, JsonRenameTableStatement, JsonSqliteAddColumnStatement, JsonSqliteCreateTableStatement, JsonStatement } from "./jsonStatements";
+import { Dialect } from "./schemaValidator";
+export declare const pgNativeTypes: Set<string>;
+declare abstract class Convertor {
+    abstract can(statement: JsonStatement, dialect: Dialect): boolean;
+    abstract convert(statement: JsonStatement): string;
+}
+export declare class SQLiteCreateTableConvertor extends Convertor {
+    can(statement: JsonStatement, dialect: Dialect): boolean;
+    convert(st: JsonSqliteCreateTableStatement): string;
+}
+export declare class SQLiteDropTableConvertor extends Convertor {
+    can(statement: JsonStatement, dialect: Dialect): boolean;
+    convert(statement: JsonDropTableStatement): string;
+}
+export declare class SqliteRenameTableConvertor extends Convertor {
+    can(statement: JsonStatement, dialect: Dialect): boolean;
+    convert(statement: JsonRenameTableStatement): string;
+}
+export declare class SQLiteAlterTableAddColumnConvertor extends Convertor {
+    can(statement: JsonStatement, dialect: Dialect): boolean;
+    convert(statement: JsonSqliteAddColumnStatement): string;
+}
+export declare class CreateSqliteIndexConvertor extends Convertor {
+    can(statement: JsonStatement, dialect: Dialect): boolean;
+    convert(statement: JsonCreateIndexStatement): string;
+}
+export declare class SqliteDropIndexConvertor extends Convertor {
+    can(statement: JsonStatement, dialect: Dialect): boolean;
+    convert(statement: JsonDropIndexStatement): string;
+}
+export declare const fromJson: (statements: JsonStatement[], dialect: Dialect) => string[];
+export {};

package/sqlite-introspect.d.ts

@@ -0,0 +1,5 @@
+import "./@types/utils";
+import { ConfigIntrospectCasing } from "./cli/commands/utils";
+import { SQLiteSchema } from "./serializer/sqliteSchema";
+export declare const indexName: (tableName: string, columns: string[]) => string;
+export declare const schemaToTypeScript: (schema: SQLiteSchema, casing: ConfigIntrospectCasing["casing"]) => string;

package/utils/words.d.ts

@@ -0,0 +1,7 @@
+export declare const prepareMigrationMetadata: (idx: number) => {
+    prefix: string;
+    suffix: string;
+    tag: string;
+};
+export declare const adjectives: string[];
+export declare const heroes: string[];

package/utils.d.ts

@@ -0,0 +1,236 @@
+import { Dialect } from "./schemaValidator";
+import { NamedWithSchema } from "./cli/commands/migrate";
+import { AnyPgTable, PgDatabase } from "drizzle-orm/pg-core";
+import { PgSchema as PgSchemaKit } from "./serializer/pgSchema";
+import { Config, DbConnection } from ".";
+export { toDrizzle as drizzleSchemaPg } from "./serializer/pgSerializer";
+export { toDrizzle as drizzleSchemaSQLite } from "./serializer/sqliteSerializer";
+export { sqlitePushIntrospect } from "./cli/commands/sqliteIntrospect";
+export { pgPushIntrospect } from "./cli/commands/pgIntrospect";
+export declare const assertV1OutFolder: (out: string, dialect: Dialect | "{dialect}") => void;
+export type Journal = {
+    version: string;
+    dialect: Dialect;
+    entries: {
+        idx: number;
+        version: string;
+        when: number;
+        tag: string;
+        breakpoints: boolean;
+    }[];
+};
+export declare const dryJournal: (dialect: Dialect) => Journal;
+export declare const snapshotsPriorV4: (out: string) => string[];
+export declare function defineConfig(config: Config): Config;
+export declare const prepareOutFolder: (out: string, dialect: Dialect) => {
+    meta: string;
+    snapshots: string[];
+    journal: any;
+};
+export declare const mapValues: <IN, OUT>(obj: Record<string, IN>, map: (input: IN) => OUT) => Record<string, OUT>;
+export declare const validateWithReport: (snapshots: string[], dialect: Dialect) => {
+    malformed: string[];
+    nonLatest: string[];
+    idsMap: Record<string, {
+        parent: string;
+        snapshots: string[];
+    }>;
+    rawMap: Record<string, any>;
+};
+export declare const prepareMigrationFolder: (outFolder: string | undefined, dialect: Dialect) => {
+    snapshots: string[];
+    journal: any;
+};
+export declare const prepareMigrationMeta: (schemas: {
+    from: string;
+    to: string;
+}[], tables: {
+    from: NamedWithSchema;
+    to: NamedWithSchema;
+}[], columns: {
+    from: {
+        table: string;
+        schema: string;
+        column: string;
+    };
+    to: {
+        table: string;
+        schema: string;
+        column: string;
+    };
+}[]) => {
+    schemas: {};
+    tables: {};
+    columns: {};
+};
+export declare const schemaRenameKey: (it: string) => string;
+export declare const tableRenameKey: (it: NamedWithSchema) => string;
+export declare const columnRenameKey: (table: string, schema: string, column: string) => string;
+export declare const kloudMeta: () => {
+    pg: number[];
+    mysql: number[];
+    sqlite: number[];
+};
+export declare const statementsForDiffs: (in1: any, in2: any) => Promise<{
+    left: {
+        internal?: {
+            tables: Record<string, {
+                columns: Record<string, {
+                    isArray?: boolean | undefined;
+                    dimensions?: number | undefined;
+                    rawType?: string | undefined;
+                } | undefined>;
+            } | undefined>;
+        } | undefined;
+        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>;
+        }>;
+    };
+    right: {
+        internal?: {
+            tables: Record<string, {
+                columns: Record<string, {
+                    isArray?: boolean | undefined;
+                    dimensions?: number | undefined;
+                    rawType?: string | undefined;
+                } | undefined>;
+            } | undefined>;
+        } | undefined;
+        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>;
+        }>;
+    };
+    statements: import("./jsonStatements").JsonStatement[];
+    sqlStatements: string[];
+    _meta: {
+        schemas: {};
+        tables: {};
+        columns: {};
+    } | undefined;
+}>;
+export type DrizzleSnapshotJSON = PgSchemaKit;
+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<{
+    hasDataLoss: boolean;
+    warnings: string[];
+    statementsToExecute: string[];
+    apply: () => Promise<void>;
+}>;
+export declare const prepareFrom: (connection: DbConnection) => Promise<{
+    db: import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, never>>;
+    type: "pg";
+    schema: Record<string, AnyPgTable<{}> | import("drizzle-orm").Relations<string, Record<string, import("drizzle-orm").Relation<string>>>> | undefined;
+} | {
+    db: import("drizzle-orm/mysql2").MySql2Database<Record<string, never>>;
+    type: "mysql";
+    schema: Record<string, import("drizzle-orm/mysql-core").AnyMySqlTable<{}> | import("drizzle-orm").Relations<string, Record<string, import("drizzle-orm").Relation<string>>>> | undefined;
+} | {
+    db: import("./orm-extenstions/d1-driver/driver").DrizzleD1WranglerDatabase<Record<string, never>>;
+    type: "sqlite";
+    schema: Record<string, import("drizzle-orm").Relations<string, Record<string, import("drizzle-orm").Relation<string>>> | import("drizzle-orm/sqlite-core").AnySQLiteTable<{}>> | undefined;
+} | {
+    db: import("drizzle-orm/better-sqlite3").BetterSQLite3Database<Record<string, never>>;
+    type: "sqlite";
+    schema: Record<string, import("drizzle-orm").Relations<string, Record<string, import("drizzle-orm").Relation<string>>> | import("drizzle-orm/sqlite-core").AnySQLiteTable<{}>> | undefined;
+} | {
+    db: import("drizzle-orm/libsql").LibSQLDatabase<Record<string, never>>;
+    type: "sqlite";
+    schema: Record<string, import("drizzle-orm").Relations<string, Record<string, import("drizzle-orm").Relation<string>>> | import("drizzle-orm/sqlite-core").AnySQLiteTable<{}>> | undefined;
+}>;