drizzle-kit 0.20.5-e91a5f5 → 0.20.5

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

@@ -0,0 +1,51 @@
+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 { SQLiteAsyncDialect, SQLiteExecuteMethod, SQLitePreparedQuery, SQLiteSession } 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";
+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 SQLitePreparedQuery<{
+    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.20.5-e91a5f5",
+  "version": "0.20.5",
   "repository": "https://github.com/drizzle-team/drizzle-kit-mirror",
   "author": "Drizzle Team",
   "license": "MIT",
@@ -10,7 +10,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",
+    "migrate:old": "drizzle-kit generate:pg --out ./dev/migrations-pg --schema ./dev/migrations-pg/schema2.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",
     "try1": "tsx ./src/t.ts",
@@ -41,7 +41,7 @@
     "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",
+    "studio": "tsx ./src/cli/index.ts studio --verbose --port=3000",
     "studio:dev": "tsx ./src/cli/index.ts studio --verbose"
   },
   "ava": {
@@ -56,17 +56,18 @@
     ]
   },
   "dependencies": {
-    "@drizzle-team/studio": "^0.0.27",
+    "@drizzle-team/studio": "^0.0.34",
     "@esbuild-kit/esm-loader": "^2.5.5",
     "camelcase": "^7.0.1",
     "chalk": "^5.2.0",
     "commander": "^9.4.1",
-    "esbuild": "^0.18.6",
-    "esbuild-register": "^3.4.2",
+    "esbuild": "^0.19.7",
+    "esbuild-register": "^3.5.0",
     "glob": "^8.1.0",
     "hanji": "^0.0.5",
     "json-diff": "0.9.0",
     "minimatch": "^7.4.3",
+    "semver": "^7.5.4",
     "wrangler": "^3.7.0",
     "zod": "^3.20.2"
   },
@@ -79,13 +80,14 @@
     "@types/minimatch": "^5.1.2",
     "@types/node": "^18.11.15",
     "@types/pg": "^8.10.7",
+    "@types/semver": "^7.5.5",
     "@typescript-eslint/eslint-plugin": "^5.46.1",
     "@typescript-eslint/parser": "^5.46.1",
     "ava": "^5.1.0",
     "better-sqlite3": "^8.4.0",
     "dockerode": "^3.3.4",
     "dotenv": "^16.0.3",
-    "drizzle-orm": "0.29.0-d3b1c58",
+    "drizzle-orm": "0.29.0",
     "esbuild-node-externals": "^1.9.0",
     "eslint": "^8.29.0",
     "eslint-config-prettier": "^8.5.0",
@@ -124,18 +126,6 @@
       },
       "types": "./utils-studio.d.mts",
       "default": "./utils-studio.mjs"
-    },
-    "./payload": {
-      "import": {
-        "types": "./payload.d.mts",
-        "default": "./payload.mjs"
-      },
-      "require": {
-        "types": "./payload.d.ts",
-        "default": "./payload.js"
-      },
-      "types": "./payload.d.mts",
-      "default": "./payload.mjs"
     }
   }
 }

package/serializer/mysqlImports.d.ts

@@ -1,9 +1,4 @@
 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: DrizzleDbClient, inputSchema: string, tablesFilter?: (table: string) => boolean, progressCallback?: ((stage: IntrospectStage, count: number, status: IntrospectStatus) => void) | undefined) => Promise<MySqlSchemaInternal>;
+export declare const fromDatabase: (db: Connection, inputSchema: string, tablesFilter?: (table: string) => boolean, progressCallback?: ((stage: IntrospectStage, count: number, status: IntrospectStatus) => void) | undefined) => Promise<MySqlSchemaInternal>;

package/serializer/sqliteImports.d.ts

@@ -1,8 +1,4 @@
 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/serializer/studioUtils.d.ts

@@ -0,0 +1,65 @@
+import type { Setup } from "@drizzle-team/studio";
+import { Relations } from "drizzle-orm";
+import { AnyMySqlTable } from "drizzle-orm/mysql-core";
+import { AnyPgTable } from "drizzle-orm/pg-core";
+import { AnySQLiteTable } from "drizzle-orm/sqlite-core";
+import { MySQLConnectionConfig } from "src/cli/validations/mysql";
+import { PgConnectionConfig } from "src/cli/validations/pg";
+import { StudioConfigConnections, StudioSqliteConnectionConfig as StudioSQLiteConnectionConfig } from "src/cli/validations/studio";
+export declare const preparePgSchema: (path: string | string[]) => Promise<{
+    schema: Record<string, Record<string, AnyPgTable<{}>>>;
+    relations: Record<string, Relations<string, Record<string, import("drizzle-orm").Relation<string>>>>;
+}>;
+export declare const prepareMySqlSchema: (path: string | string[]) => Promise<{
+    schema: Record<string, Record<string, AnyMySqlTable<{}>>>;
+    relations: Record<string, Relations<string, Record<string, import("drizzle-orm").Relation<string>>>>;
+}>;
+export declare const prepareSQLiteSchema: (path: string | string[]) => Promise<{
+    schema: Record<string, Record<string, AnySQLiteTable<{}>>>;
+    relations: Record<string, Relations<string, Record<string, import("drizzle-orm").Relation<string>>>>;
+}>;
+export declare const prepareModels: (path: string | string[]) => Promise<{
+    pgSchema: Record<string, AnyPgTable<{}> | Relations<string, Record<string, import("drizzle-orm").Relation<string>>>>;
+    mysqlSchema: Record<string, AnyMySqlTable<{}> | Relations<string, Record<string, import("drizzle-orm").Relation<string>>>>;
+    sqliteSchema: Record<string, Relations<string, Record<string, import("drizzle-orm").Relation<string>>> | AnySQLiteTable<{}>>;
+}>;
+export declare const drizzleForPostgres: (connectionConfig: PgConnectionConfig, pgSchema: Record<string, Record<string, AnyPgTable>>, relations: Record<string, Relations>, ts: {
+    imports: string;
+    declarations: string;
+    schemaEntry: string;
+}, verbose: boolean) => Promise<Setup>;
+export declare const drizzleForMySQL: (config: MySQLConnectionConfig, mysqlSchema: Record<string, Record<string, AnyMySqlTable>>, relations: Record<string, Relations>, ts: {
+    imports: string;
+    declarations: string;
+    schemaEntry: string;
+}, verbose: boolean) => Promise<Setup>;
+export declare const drizzleForSQLite: (config: StudioSQLiteConnectionConfig, sqliteSchema: Record<string, Record<string, AnySQLiteTable>>, relations: Record<string, Relations>, ts: {
+    imports: string;
+    declarations: string;
+    schemaEntry: string;
+}, verbose: boolean) => Promise<Setup>;
+export declare const drizzleDb: (drizzleConfig: StudioConfigConnections, models: {
+    pgSchema?: Record<string, AnyPgTable | Relations>;
+    mysqlSchema?: Record<string, AnyMySqlTable | Relations>;
+    sqliteSchema?: Record<string, AnySQLiteTable | Relations>;
+}, logger: boolean) => Promise<{
+    db: import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, never>>;
+    type: "pg";
+    schema: Record<string, AnyPgTable<{}> | Relations<string, Record<string, import("drizzle-orm").Relation<string>>>> | undefined;
+} | {
+    db: import("drizzle-orm/mysql2").MySql2Database<Record<string, never>>;
+    type: "mysql";
+    schema: Record<string, AnyMySqlTable<{}> | 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, Relations<string, Record<string, import("drizzle-orm").Relation<string>>> | AnySQLiteTable<{}>> | undefined;
+} | {
+    db: import("drizzle-orm/better-sqlite3").BetterSQLite3Database<Record<string, never>>;
+    type: "sqlite";
+    schema: Record<string, Relations<string, Record<string, import("drizzle-orm").Relation<string>>> | AnySQLiteTable<{}>> | undefined;
+} | {
+    db: import("drizzle-orm/libsql").LibSQLDatabase<Record<string, never>>;
+    type: "sqlite";
+    schema: Record<string, Relations<string, Record<string, import("drizzle-orm").Relation<string>>> | AnySQLiteTable<{}>> | undefined;
+}>;