drizzle-kit 0.19.14-039355d → 0.20.0-13160ca

package/index.d.ts

@@ -1,3 +1,49 @@
+export type DbConnection = {
+    driver: "turso";
+    dbCredentials: {
+        url: string;
+        authToken?: string;
+    };
+} | {
+    driver: "better-sqlite";
+    dbCredentials: {
+        url: string;
+    };
+} | {
+    driver: "libsql";
+    dbCredentials: {
+        url: string;
+    };
+} | {
+    driver: "d1";
+    dbCredentials: {
+        wranglerConfigPath: string;
+        dbName: string;
+    };
+} | {
+    driver: "pg";
+    dbCredentials: {
+        host: string;
+        port?: number;
+        user?: string;
+        password?: string;
+        database: string;
+        ssl?: boolean;
+    } | {
+        connectionString: string;
+    };
+} | {
+    driver: "mysql2";
+    dbCredentials: {
+        host: string;
+        port?: number;
+        user?: string;
+        password?: string;
+        database: string;
+    } | {
+        connectionString: string;
+    };
+};
 export type Config = {
     out?: string | undefined;
     breakpoints?: boolean | undefined;
@@ -53,5 +99,7 @@ export type Config = {
     driver: "d1";
     dbCredentials: {
         wranglerConfigPath: string;
+        dbName: string;
     };
 } | {});
+export declare function defineConfig(config: Config): Config;

package/introspect.d.ts

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

package/jsonDiffer.d.ts

@@ -0,0 +1,76 @@
+export function diffForRenamedTables(pairs: any): any;
+export function diffForRenamedColumn(t1: any, t2: any): any;
+export function applyJsonDiff(json1: any, json2: any): {
+    addedTables?: undefined;
+    deletedTables?: undefined;
+    alteredTablesWithColumns?: undefined;
+    addedEnums?: undefined;
+    deletedEnums?: undefined;
+    alteredEnums?: undefined;
+    addedSchemas?: undefined;
+    deletedSchemas?: undefined;
+} | {
+    addedTables: any[];
+    deletedTables: any[];
+    alteredTablesWithColumns: {
+        name: any;
+        schema: {
+            type: string;
+            value: any;
+        };
+        deleted: any[];
+        added: any[];
+        altered: any[];
+        addedIndexes: {
+            [k: string]: any;
+        };
+        deletedIndexes: {
+            [k: string]: any;
+        };
+        alteredIndexes: {
+            [k: string]: any;
+        };
+        addedForeignKeys: {
+            [k: string]: any;
+        };
+        deletedForeignKeys: {
+            [k: string]: any;
+        };
+        alteredForeignKeys: {
+            [k: string]: any;
+        };
+        addedCompositePKs: {
+            [k: string]: any;
+        };
+        deletedCompositePKs: {
+            [k: string]: any;
+        };
+        alteredCompositePKs: {
+            [k: string]: any;
+        };
+        addedUniqueConstraints: {
+            [k: string]: any;
+        };
+        deletedUniqueConstraints: {
+            [k: string]: any;
+        };
+        alteredUniqueConstraints: {
+            [k: string]: any;
+        };
+    }[];
+    addedEnums: {
+        name: any;
+        values: any[];
+    }[];
+    deletedEnums: {
+        name: any;
+        values: any[];
+    }[];
+    alteredEnums: {
+        name: string;
+        addedValues: any[];
+        deletedValues: any[];
+    }[];
+    addedSchemas: any[];
+    deletedSchemas: any[];
+};

package/jsonStatements.d.ts

@@ -0,0 +1,349 @@
+import { CommonSquashedSchema, Dialect } from "./schemaValidator";
+import { MySqlSchema } from "./serializer/mysqlSchema";
+import { PgSchema } from "./serializer/pgSchema";
+import { AlteredColumn, Column, Table } from "./snapshotsDiffer";
+export interface JsonSqliteCreateTableStatement {
+    type: "sqlite_create_table";
+    tableName: string;
+    columns: Column[];
+    referenceData: string[];
+    compositePKs: string[][];
+    uniqueConstraints?: string[];
+}
+export interface JsonCreateTableStatement {
+    type: "create_table";
+    tableName: string;
+    schema: string;
+    columns: Column[];
+    compositePKs: string[];
+    compositePkName?: string;
+    uniqueConstraints?: string[];
+}
+export interface JsonDropTableStatement {
+    type: "drop_table";
+    tableName: string;
+    schema: string;
+}
+export interface JsonRenameTableStatement {
+    type: "rename_table";
+    fromSchema: string;
+    toSchema: string;
+    tableNameFrom: string;
+    tableNameTo: string;
+}
+export interface JsonCreateEnumStatement {
+    type: "create_type_enum";
+    name: string;
+    values: string[];
+}
+export interface JsonAddValueToEnumStatement {
+    type: "alter_type_add_value";
+    name: string;
+    value: string;
+}
+export interface JsonDropColumnStatement {
+    type: "alter_table_drop_column";
+    tableName: string;
+    columnName: string;
+    schema: string;
+}
+export interface JsonAddColumnStatement {
+    type: "alter_table_add_column";
+    tableName: string;
+    column: Column;
+    schema: string;
+}
+export interface JsonSqliteAddColumnStatement {
+    type: "sqlite_alter_table_add_column";
+    tableName: string;
+    column: Column;
+    referenceData?: string;
+}
+export interface JsonCreateIndexStatement {
+    type: "create_index";
+    tableName: string;
+    data: string;
+    schema: string;
+}
+export interface JsonReferenceStatement {
+    type: "create_reference" | "alter_reference" | "delete_reference";
+    data: string;
+    schema: string;
+    tableName: string;
+}
+export interface JsonCreateUniqueConstraint {
+    type: "create_unique_constraint";
+    tableName: string;
+    data: string;
+    schema?: string;
+    constraintName?: string;
+}
+export interface JsonDeleteUniqueConstraint {
+    type: "delete_unique_constraint";
+    tableName: string;
+    data: string;
+    schema?: string;
+    constraintName?: string;
+}
+export interface JsonAlterUniqueConstraint {
+    type: "alter_unique_constraint";
+    tableName: string;
+    old: string;
+    new: string;
+    schema?: string;
+    oldConstraintName?: string;
+    newConstraintName?: string;
+}
+export interface JsonCreateCompositePK {
+    type: "create_composite_pk";
+    tableName: string;
+    data: string;
+    schema?: string;
+    constraintName?: string;
+}
+export interface JsonDeleteCompositePK {
+    type: "delete_composite_pk";
+    tableName: string;
+    data: string;
+    schema?: string;
+    constraintName?: string;
+}
+export interface JsonAlterCompositePK {
+    type: "alter_composite_pk";
+    tableName: string;
+    old: string;
+    new: string;
+    schema?: string;
+    oldConstraintName?: string;
+    newConstraintName?: string;
+}
+export interface JsonAlterTableSetSchema {
+    type: "alter_table_set_schema";
+    tableName: string;
+    schema: string;
+}
+export interface JsonAlterTableRemoveFromSchema {
+    type: "alter_table_remove_from_schema";
+    tableName: string;
+    schema: string;
+}
+export interface JsonAlterTableSetNewSchema {
+    type: "alter_table_set_new_schema";
+    tableName: string;
+    from: string;
+    to: string;
+}
+export interface JsonCreateReferenceStatement extends JsonReferenceStatement {
+    type: "create_reference";
+}
+export interface JsonAlterReferenceStatement extends JsonReferenceStatement {
+    type: "alter_reference";
+    oldFkey: string;
+}
+export interface JsonDeleteReferenceStatement extends JsonReferenceStatement {
+    type: "delete_reference";
+}
+export interface JsonDropIndexStatement {
+    type: "drop_index";
+    tableName: string;
+    data: string;
+    schema: string;
+}
+export interface JsonRenameColumnStatement {
+    type: "alter_table_rename_column";
+    tableName: string;
+    oldColumnName: string;
+    newColumnName: string;
+    schema: string;
+}
+export interface JsonAlterColumnTypeStatement {
+    type: "alter_table_alter_column_set_type";
+    tableName: string;
+    columnName: string;
+    newDataType: string;
+    oldDataType: string;
+    schema: string;
+    columnDefault: string;
+    columnOnUpdate: boolean;
+    columnNotNull: boolean;
+    columnAutoIncrement: boolean;
+    columnPk: boolean;
+}
+export interface JsonAlterColumnSetPrimaryKeyStatement {
+    type: "alter_table_alter_column_set_pk";
+    tableName: string;
+    schema: string;
+    columnName: string;
+}
+export interface JsonAlterColumnDropPrimaryKeyStatement {
+    type: "alter_table_alter_column_drop_pk";
+    tableName: string;
+    columnName: string;
+    schema: string;
+}
+export interface JsonAlterColumnSetDefaultStatement {
+    type: "alter_table_alter_column_set_default";
+    tableName: string;
+    columnName: string;
+    newDefaultValue: any;
+    oldDefaultValue?: any;
+    schema: string;
+    newDataType: string;
+    columnOnUpdate: boolean;
+    columnNotNull: boolean;
+    columnAutoIncrement: boolean;
+    columnPk: boolean;
+}
+export interface JsonAlterColumnDropDefaultStatement {
+    type: "alter_table_alter_column_drop_default";
+    tableName: string;
+    columnName: string;
+    schema: string;
+    newDataType: string;
+    columnDefault: string;
+    columnOnUpdate: boolean;
+    columnNotNull: boolean;
+    columnAutoIncrement: boolean;
+    columnPk: boolean;
+}
+export interface JsonAlterColumnSetNotNullStatement {
+    type: "alter_table_alter_column_set_notnull";
+    tableName: string;
+    columnName: string;
+    schema: string;
+    newDataType: string;
+    columnDefault: string;
+    columnOnUpdate: boolean;
+    columnNotNull: boolean;
+    columnAutoIncrement: boolean;
+    columnPk: boolean;
+}
+export interface JsonAlterColumnDropNotNullStatement {
+    type: "alter_table_alter_column_drop_notnull";
+    tableName: string;
+    columnName: string;
+    schema: string;
+    newDataType: string;
+    columnDefault: string;
+    columnOnUpdate: boolean;
+    columnNotNull: boolean;
+    columnAutoIncrement: boolean;
+    columnPk: boolean;
+}
+export interface JsonAlterColumnSetOnUpdateStatement {
+    type: "alter_table_alter_column_set_on_update";
+    tableName: string;
+    columnName: string;
+    schema: string;
+    newDataType: string;
+    columnDefault: string;
+    columnOnUpdate: boolean;
+    columnNotNull: boolean;
+    columnAutoIncrement: boolean;
+    columnPk: boolean;
+}
+export interface JsonAlterColumnDropOnUpdateStatement {
+    type: "alter_table_alter_column_drop_on_update";
+    tableName: string;
+    columnName: string;
+    schema: string;
+    newDataType: string;
+    columnDefault: string;
+    columnOnUpdate: boolean;
+    columnNotNull: boolean;
+    columnAutoIncrement: boolean;
+    columnPk: boolean;
+}
+export interface JsonAlterColumnSetAutoincrementStatement {
+    type: "alter_table_alter_column_set_autoincrement";
+    tableName: string;
+    columnName: string;
+    schema: string;
+    newDataType: string;
+    columnDefault: string;
+    columnOnUpdate: boolean;
+    columnNotNull: boolean;
+    columnAutoIncrement: boolean;
+    columnPk: boolean;
+}
+export interface JsonAlterColumnDropAutoincrementStatement {
+    type: "alter_table_alter_column_drop_autoincrement";
+    tableName: string;
+    columnName: string;
+    schema: string;
+    newDataType: string;
+    columnDefault: string;
+    columnOnUpdate: boolean;
+    columnNotNull: boolean;
+    columnAutoIncrement: boolean;
+    columnPk: boolean;
+}
+export interface JsonCreateSchema {
+    type: "create_schema";
+    name: string;
+}
+export interface JsonDropSchema {
+    type: "drop_schema";
+    name: string;
+}
+export interface JsonRenameSchema {
+    type: "rename_schema";
+    from: string;
+    to: string;
+}
+export type JsonAlterColumnStatement = JsonRenameColumnStatement | JsonAlterColumnTypeStatement | JsonAlterColumnSetDefaultStatement | JsonAlterColumnDropDefaultStatement | JsonAlterColumnSetNotNullStatement | JsonAlterColumnDropNotNullStatement | JsonAlterColumnDropOnUpdateStatement | JsonAlterColumnSetOnUpdateStatement | JsonAlterColumnDropAutoincrementStatement | JsonAlterColumnSetAutoincrementStatement | JsonAlterColumnSetPrimaryKeyStatement | JsonAlterColumnDropPrimaryKeyStatement;
+export type JsonStatement = JsonAlterColumnStatement | JsonCreateTableStatement | JsonDropTableStatement | JsonRenameTableStatement | JsonCreateEnumStatement | JsonAddValueToEnumStatement | JsonDropColumnStatement | JsonAddColumnStatement | JsonCreateIndexStatement | JsonCreateReferenceStatement | JsonAlterReferenceStatement | JsonDeleteReferenceStatement | JsonDropIndexStatement | JsonReferenceStatement | JsonSqliteCreateTableStatement | JsonSqliteAddColumnStatement | JsonCreateCompositePK | JsonDeleteCompositePK | JsonAlterCompositePK | JsonCreateUniqueConstraint | JsonDeleteUniqueConstraint | JsonAlterUniqueConstraint | JsonCreateSchema | JsonDropSchema | JsonRenameSchema | JsonAlterTableSetSchema | JsonAlterTableRemoveFromSchema | JsonAlterTableSetNewSchema;
+export declare const preparePgCreateTableJson: (table: Table, json2: PgSchema) => JsonCreateTableStatement;
+export declare const prepareMySqlCreateTableJson: (table: Table, json2: PgSchema) => JsonCreateTableStatement;
+export declare const prepareSQLiteCreateTable: (table: Table) => JsonSqliteCreateTableStatement;
+export declare const prepareDropTableJson: (table: Table) => JsonDropTableStatement;
+export declare const prepareRenameTableJson: (tableFrom: Table, tableTo: Table) => JsonRenameTableStatement;
+export declare const prepareCreateEnumJson: (name: string, values: string[]) => JsonCreateEnumStatement;
+export declare const prepareAddValuesToEnumJson: (name: string, values: string[]) => JsonAddValueToEnumStatement[];
+export declare const prepareCreateSchemasJson: (values: string[]) => JsonCreateSchema[];
+export declare const prepareRenameSchemasJson: (values: {
+    from: string;
+    to: string;
+}[]) => JsonRenameSchema[];
+export declare const prepareDeleteSchemasJson: (values: string[]) => JsonDropSchema[];
+export declare const prepareRenameColumns: (tableName: string, schema: string, pairs: {
+    from: Column;
+    to: Column;
+}[]) => JsonRenameColumnStatement[];
+export declare const prepareAlterTableColumnsJson: (tableName: string, schema: string, deleted: Column[], added: Column[], altered: AlteredColumn[], addedFk: Record<string, string>, json2: CommonSquashedSchema, dialect?: Dialect) => {
+    addColumns: JsonStatement[];
+    dropColumns: JsonDropColumnStatement[];
+    alterColumns: JsonAlterColumnStatement[];
+};
+export declare const prepareCreateIndexesJson: (tableName: string, schema: string, indexes: Record<string, string>) => JsonCreateIndexStatement[];
+export declare const prepareCreateReferencesJson: (tableName: string, schema: string, foreignKeys: Record<string, string>) => JsonCreateReferenceStatement[];
+export declare const prepareDropReferencesJson: (tableName: string, schema: string, foreignKeys: Record<string, string>) => JsonDeleteReferenceStatement[];
+export declare const prepareAlterReferencesJson: (tableName: string, schema: string, foreignKeys: Record<string, {
+    __old: string;
+    __new: string;
+}>) => JsonReferenceStatement[];
+export declare const prepareDropIndexesJson: (tableName: string, schema: string, indexes: Record<string, string>) => JsonDropIndexStatement[];
+export declare const prepareAddCompositePrimaryKeySqlite: (tableName: string, pks: Record<string, string>) => JsonCreateCompositePK[];
+export declare const prepareDeleteCompositePrimaryKeySqlite: (tableName: string, pks: Record<string, string>) => JsonDeleteCompositePK[];
+export declare const prepareAlterCompositePrimaryKeySqlite: (tableName: string, pks: Record<string, {
+    __old: string;
+    __new: string;
+}>) => JsonAlterCompositePK[];
+export declare const prepareAddCompositePrimaryKeyPg: (tableName: string, schema: string, pks: Record<string, string>, json2: PgSchema) => JsonCreateCompositePK[];
+export declare const prepareDeleteCompositePrimaryKeyPg: (tableName: string, schema: string, pks: Record<string, string>, json1: PgSchema) => JsonDeleteCompositePK[];
+export declare const prepareAlterCompositePrimaryKeyPg: (tableName: string, schema: string, pks: Record<string, {
+    __old: string;
+    __new: string;
+}>, json1: PgSchema, json2: PgSchema) => JsonAlterCompositePK[];
+export declare const prepareAddUniqueConstraintPg: (tableName: string, schema: string, unqs: Record<string, string>) => JsonCreateUniqueConstraint[];
+export declare const prepareDeleteUniqueConstraintPg: (tableName: string, schema: string, unqs: Record<string, string>) => JsonDeleteUniqueConstraint[];
+export declare const prepareAlterUniqueConstraintPg: (tableName: string, schema: string, unqs: Record<string, {
+    __old: string;
+    __new: string;
+}>) => JsonAlterUniqueConstraint[];
+export declare const prepareAddCompositePrimaryKeyMySql: (tableName: string, pks: Record<string, string>, json1: MySqlSchema, json2: MySqlSchema) => JsonCreateCompositePK[];
+export declare const prepareDeleteCompositePrimaryKeyMySql: (tableName: string, pks: Record<string, string>, json1: MySqlSchema) => JsonDeleteCompositePK[];
+export declare const prepareAlterCompositePrimaryKeyMySql: (tableName: string, pks: Record<string, {
+    __old: string;
+    __new: string;
+}>, json1: MySqlSchema, json2: MySqlSchema) => JsonAlterCompositePK[];

package/migrationPreparator.d.ts

@@ -0,0 +1,35 @@
+import { PgSchema, PgSchemaInternal } from "./serializer/pgSchema";
+import { SQLiteSchema } from "./serializer/sqliteSchema";
+import { MySqlSchema } from "./serializer/mysqlSchema";
+export declare const prepareMySqlDbPushSnapshot: (prev: MySqlSchema, schemaPath: string | string[]) => Promise<{
+    prev: MySqlSchema;
+    cur: MySqlSchema;
+}>;
+export declare const prepareSQLiteDbPushSnapshot: (prev: SQLiteSchema, schemaPath: string | string[]) => Promise<{
+    prev: SQLiteSchema;
+    cur: SQLiteSchema;
+}>;
+export declare const preparePgDbPushSnapshot: (prev: PgSchema, schemaPath: string | string[], schemaFilter?: string[]) => Promise<{
+    prev: PgSchema;
+    cur: PgSchema;
+}>;
+export declare const prepareMySqlMigrationSnapshot: (migrationFolders: string[], schemaPath: string | string[]) => Promise<{
+    prev: MySqlSchema;
+    cur: MySqlSchema;
+    custom: MySqlSchema;
+}>;
+export declare const prepareSqliteMigrationSnapshot: (snapshots: string[], schemaPath: string | string[]) => Promise<{
+    prev: SQLiteSchema;
+    cur: SQLiteSchema;
+    custom: SQLiteSchema;
+}>;
+export declare const fillPgSnapshot: ({ serialized, id, idPrev, }: {
+    serialized: PgSchemaInternal;
+    id: string;
+    idPrev: string;
+}) => PgSchema;
+export declare const preparePgMigrationSnapshot: (snapshots: string[], schemaPath: string | string[]) => Promise<{
+    prev: PgSchema;
+    cur: PgSchema;
+    custom: PgSchema;
+}>;

package/orm-extenstions/d1-driver/driver.d.ts

@@ -0,0 +1,8 @@
+import { type DrizzleConfig, QueryWithTypings, SQL } from "drizzle-orm";
+import { BaseSQLiteDatabase, SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
+import { D1WranglerResults } from "./session";
+export type DrizzleD1WranglerDatabase<TSchema extends Record<string, unknown> = Record<string, never>> = BaseSQLiteDatabase<"async", D1WranglerResults, TSchema>;
+export declare class WranglerDialect extends SQLiteAsyncDialect {
+    sqlToQuery(sql: SQL): QueryWithTypings;
+}
+export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(client: (query: string, configPath: string, dbName: string) => Promise<any>, configPath: string, dbName: string, config?: DrizzleConfig<TSchema>): DrizzleD1WranglerDatabase<TSchema>;

package/orm-extenstions/d1-driver/session.d.ts

@@ -0,0 +1,52 @@
+import { entityKind } from "drizzle-orm";
+import type { Logger } from "drizzle-orm";
+import { type RelationalSchemaConfig, type TablesRelationalConfig } from "drizzle-orm";
+import { type Query } from "drizzle-orm";
+import type { SQLiteAsyncDialect, SQLiteExecuteMethod } from "drizzle-orm/sqlite-core";
+import type { SelectedFieldsOrdered } from "drizzle-orm/sqlite-core";
+import { type PreparedQueryConfig as PreparedQueryConfigBase, type SQLiteTransactionConfig } from "drizzle-orm/sqlite-core";
+import { PreparedQuery as PreparedQueryBase, SQLiteSession } from "drizzle-orm/sqlite-core";
+export interface SQLiteD1SessionOptions {
+    logger?: Logger;
+}
+type PreparedQueryConfig = Omit<PreparedQueryConfigBase, "statement" | "run">;
+export type D1WranglerResults<T = unknown> = {
+    results?: T[];
+};
+export declare class SQLiteWranglerD1Session<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends SQLiteSession<"async", D1WranglerResults, TFullSchema, TSchema> {
+    private client;
+    private configPath;
+    private dbName;
+    private schema;
+    private options;
+    static readonly [entityKind]: string;
+    private logger;
+    constructor(client: (query: string, configPath: string, dbName: string) => Promise<any>, configPath: string, dbName: string, dialect: SQLiteAsyncDialect, schema: RelationalSchemaConfig<TSchema> | undefined, options?: SQLiteD1SessionOptions);
+    prepareQuery(query: Query, fields: SelectedFieldsOrdered | undefined, executeMethod: SQLiteExecuteMethod, customResultMapper?: (rows: unknown[][]) => unknown): PreparedQuery;
+    transaction<T>(transaction: (tx: any) => T | Promise<T>, config?: SQLiteTransactionConfig): Promise<T>;
+}
+export declare class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig> extends PreparedQueryBase<{
+    type: "async";
+    run: D1WranglerResults;
+    all: T["all"];
+    get: T["get"];
+    values: T["values"];
+    execute: T["execute"];
+}> {
+    private stmt;
+    private configPath;
+    private dbName;
+    private queryString;
+    private params;
+    private logger;
+    private fields;
+    private customResultMapper?;
+    static readonly [entityKind]: string;
+    constructor(stmt: (query: string, configPath: string, dbName: string) => Promise<any>, configPath: string, dbName: string, queryString: string, params: unknown[], logger: Logger, fields: SelectedFieldsOrdered | undefined, executeMethod: SQLiteExecuteMethod, customResultMapper?: ((rows: unknown[][]) => unknown) | undefined);
+    run(placeholderValues?: Record<string, unknown>): Promise<D1WranglerResults>;
+    all(placeholderValues?: Record<string, unknown>): Promise<T["all"]>;
+    get(placeholderValues?: Record<string, unknown>): Promise<T["get"]>;
+    private d1ToRawMapping;
+    values(placeholderValues?: Record<string, unknown>): Promise<unknown[][]>;
+}
+export {};

package/orm-extenstions/d1-driver/wrangler-client.d.ts

@@ -0,0 +1,3 @@
+export declare function execute(query: string, configPath: string, dbName: string): Promise<{
+    results: any;
+}>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drizzle-kit",
-  "version": "0.19.14-039355d",
+  "version": "0.20.0-13160ca",
   "repository": "https://github.com/drizzle-team/drizzle-kit-mirror",
   "author": "Drizzle Team",
   "license": "MIT",
@@ -9,6 +9,7 @@
   },
   "scripts": {
     "test:pg:push": "drizzle-kit push:pg",
+    "payload": "tsx ./dev/payload.ts",
     "migrate:old": "drizzle-kit generate:pg --out ./dev/migrations-pg --schema ./dev/migrations-pg/schema.ts",
     "push": "node -r esbuild-register ./src/cli/index.ts push:mysql",
     "push:sqlite": "node -r ./src/loader.mjs ./src/cli/index.ts push:sqlite",
@@ -36,7 +37,7 @@
     "test": "ava test --timeout=60s",
     "build": "rm -rf ./dist && tsx build.ts && tsc -p tsconfig.cli-types.json",
     "build:dev": "rm -rf ./dist && tsx build.dev.ts && tsc -p tsconfig.cli-types.json && chmod +x ./dist/index.cjs",
-    "pack": "build && package",
+    "packit": "pnpm build && cp package.json dist/ && cd dist && pnpm pack",
     "tsc": "tsc -p tsconfig.build.json",
     "pub": "cp package.json readme.md dist/ && cd dist && npm publish",
     "studio": "./dist/index.cjs studio --verbose"
@@ -53,7 +54,7 @@
     ]
   },
   "dependencies": {
-    "@drizzle-team/studio": "^0.0.5",
+    "@drizzle-team/studio": "^0.0.17",
     "@esbuild-kit/esm-loader": "^2.5.5",
     "camelcase": "^7.0.1",
     "chalk": "^5.2.0",
@@ -82,7 +83,7 @@
     "better-sqlite3": "^8.4.0",
     "dockerode": "^3.3.4",
     "dotenv": "^16.0.3",
-    "drizzle-orm": "0.28.6",
+    "drizzle-orm": "0.28.7-4e094f0",
     "eslint": "^8.29.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-prettier": "^4.2.1",