@duckdbfan/drizzle-duckdb 0.0.3 → 0.0.5

package/dist/index.mjs

@@ -0,0 +1,429 @@
+// src/driver.ts
+import { entityKind as entityKind3, is as is3 } from "drizzle-orm/entity";
+import { DefaultLogger } from "drizzle-orm/logger";
+import { PgDatabase } from "drizzle-orm/pg-core/db";
+import {
+  createTableRelationsHelpers,
+  extractTablesRelationalConfig
+} from "drizzle-orm/relations";
+import {
+  getTableColumns
+} from "drizzle-orm/utils";
+
+// src/session.ts
+import { entityKind } from "drizzle-orm/entity";
+import { NoopLogger } from "drizzle-orm/logger";
+import { PgTransaction } from "drizzle-orm/pg-core";
+import { PgPreparedQuery, PgSession } from "drizzle-orm/pg-core/session";
+import { fillPlaceholders, sql as sql2 } from "drizzle-orm/sql/sql";
+
+// src/utils.ts
+import {
+  is,
+  Column,
+  SQL,
+  getTableName,
+  sql
+} from "drizzle-orm";
+function mapResultRow(columns, row, joinsNotNullableMap) {
+  const nullifyMap = {};
+  const result = columns.reduce((result2, { path, field }, columnIndex) => {
+    let decoder;
+    if (is(field, Column)) {
+      decoder = field;
+    } else if (is(field, SQL)) {
+      decoder = field.decoder;
+    } else {
+      decoder = field.sql.decoder;
+    }
+    let node = result2;
+    for (const [pathChunkIndex, pathChunk] of path.entries()) {
+      if (pathChunkIndex < path.length - 1) {
+        if (!(pathChunk in node)) {
+          node[pathChunk] = {};
+        }
+        node = node[pathChunk];
+        continue;
+      }
+      const rawValue = row[columnIndex];
+      const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
+      if (joinsNotNullableMap && is(field, Column) && path.length === 2) {
+        const objectName = path[0];
+        if (!(objectName in nullifyMap)) {
+          nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
+        } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) {
+          nullifyMap[objectName] = false;
+        }
+        continue;
+      }
+      if (joinsNotNullableMap && is(field, SQL.Aliased) && path.length === 2) {
+        const col = field.sql.queryChunks.find((chunk) => is(chunk, Column));
+        const tableName = col?.table && getTableName(col?.table);
+        if (!tableName) {
+          continue;
+        }
+        const objectName = path[0];
+        if (!(objectName in nullifyMap)) {
+          nullifyMap[objectName] = value === null ? tableName : false;
+          continue;
+        }
+        if (nullifyMap[objectName] && nullifyMap[objectName] !== tableName) {
+          nullifyMap[objectName] = false;
+        }
+        continue;
+      }
+    }
+    return result2;
+  }, {});
+  if (joinsNotNullableMap && Object.keys(nullifyMap).length > 0) {
+    for (const [objectName, tableName] of Object.entries(nullifyMap)) {
+      if (typeof tableName === "string" && !joinsNotNullableMap[tableName]) {
+        result[objectName] = null;
+      }
+    }
+  }
+  return result;
+}
+function aliasFields(fields, fullJoin = false) {
+  return Object.fromEntries(Object.entries(fields).filter(([key]) => key !== "enableRLS").map(([key, value]) => {
+    if (fullJoin && is(value, Column)) {
+      return [
+        key,
+        sql`${value}`.as(`${getTableName(value.table)}.${value.name}`)
+      ];
+    }
+    if (fullJoin && is(value, SQL)) {
+      const col = value.getSQL().queryChunks.find((chunk) => is(chunk, Column));
+      const tableName = col?.table && getTableName(col?.table);
+      return [key, value.as(tableName ? `${tableName}.${key}` : key)];
+    }
+    if (is(value, SQL) || is(value, Column)) {
+      return [key, (is(value, SQL) ? value : sql`${value}`).as(key)];
+    }
+    if (is(value, SQL.Aliased)) {
+      return [key, value];
+    }
+    if (typeof value === "object") {
+      const parentKey = key;
+      return [
+        key,
+        Object.fromEntries(Object.entries(value).filter(([childKey]) => childKey !== "enableRLS").map(([childKey, childValue]) => [
+          childKey,
+          (is(childValue, SQL) ? childValue : sql`${childValue}`).as(`${parentKey}.${childKey}`)
+        ]))
+      ];
+    }
+    return [key, value];
+  }));
+}
+var tableIdPropSelectionRegex = new RegExp([
+  `("(.+)"\\."(.+)")`,
+  `(\\s+as\\s+'?(.+?)'?\\.'?(.+?)'?)?`
+].join(""), "i");
+
+// src/session.ts
+import { TransactionRollbackError } from "drizzle-orm/errors";
+
+class DuckDBPreparedQuery extends PgPreparedQuery {
+  client;
+  queryString;
+  params;
+  logger;
+  fields;
+  _isResponseInArrayMode;
+  customResultMapper;
+  static [entityKind] = "DuckDBPreparedQuery";
+  constructor(client, queryString, params, logger, fields, _isResponseInArrayMode, customResultMapper) {
+    super({ sql: queryString, params });
+    this.client = client;
+    this.queryString = queryString;
+    this.params = params;
+    this.logger = logger;
+    this.fields = fields;
+    this._isResponseInArrayMode = _isResponseInArrayMode;
+    this.customResultMapper = customResultMapper;
+  }
+  async execute(placeholderValues = {}) {
+    const params = fillPlaceholders(this.params, placeholderValues);
+    this.logger.logQuery(this.queryString, params);
+    const {
+      fields,
+      client,
+      joinsNotNullableMap,
+      customResultMapper,
+      queryString
+    } = this;
+    const rows = await client.all(queryString, ...params) ?? [];
+    if (rows.length === 0 || !fields) {
+      return rows;
+    }
+    const rowValues = rows.map((row) => Object.values(row));
+    return customResultMapper ? customResultMapper(rowValues) : rowValues.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
+  }
+  all(placeholderValues = {}) {
+    return this.execute(placeholderValues);
+  }
+  isResponseInArrayMode() {
+    return false;
+  }
+}
+
+class DuckDBSession extends PgSession {
+  client;
+  schema;
+  options;
+  static [entityKind] = "DuckDBSession";
+  logger;
+  constructor(client, dialect, schema, options = {}) {
+    super(dialect);
+    this.client = client;
+    this.schema = schema;
+    this.options = options;
+    this.logger = options.logger ?? new NoopLogger;
+  }
+  prepareQuery(query, fields, name, isResponseInArrayMode, customResultMapper) {
+    return new DuckDBPreparedQuery(this.client, query.sql, query.params, this.logger, fields, isResponseInArrayMode, customResultMapper);
+  }
+  async transaction(transaction) {
+    const connection = "connect" in this.client ? await this.client.connect() : this.client;
+    const session = new DuckDBSession(connection, this.dialect, this.schema, this.options);
+    const tx = new DuckDBTransaction(this.dialect, session, this.schema);
+    await tx.execute(sql2`BEGIN TRANSACTION;`);
+    try {
+      const result = await transaction(tx);
+      await tx.execute(sql2`commit`);
+      return result;
+    } catch (error) {
+      await tx.execute(sql2`rollback`);
+      throw error;
+    } finally {
+      await connection.close();
+    }
+  }
+}
+
+class DuckDBTransaction extends PgTransaction {
+  static [entityKind] = "DuckDBTransaction";
+  rollback() {
+    throw new TransactionRollbackError;
+  }
+  getTransactionConfigSQL(config) {
+    const chunks = [];
+    if (config.isolationLevel) {
+      chunks.push(`isolation level ${config.isolationLevel}`);
+    }
+    if (config.accessMode) {
+      chunks.push(config.accessMode);
+    }
+    if (typeof config.deferrable === "boolean") {
+      chunks.push(config.deferrable ? "deferrable" : "not deferrable");
+    }
+    return sql2.raw(chunks.join(" "));
+  }
+  setTransaction(config) {
+    return this.session.execute(sql2`set transaction ${this.getTransactionConfigSQL(config)}`);
+  }
+  async transaction(transaction) {
+    const savepointName = `sp${this.nestedIndex + 1}`;
+    const tx = new DuckDBTransaction(this.dialect, this.session, this.schema, this.nestedIndex + 1);
+    await tx.execute(sql2.raw(`savepoint ${savepointName}`));
+    try {
+      const result = await transaction(tx);
+      await tx.execute(sql2.raw(`release savepoint ${savepointName}`));
+      return result;
+    } catch (err) {
+      await tx.execute(sql2.raw(`rollback to savepoint ${savepointName}`));
+      throw err;
+    }
+  }
+}
+
+// src/dialect.ts
+import { entityKind as entityKind2, is as is2 } from "drizzle-orm/entity";
+import {
+  PgDate,
+  PgDateString,
+  PgDialect,
+  PgJson,
+  PgJsonb,
+  PgNumeric,
+  PgTime,
+  PgTimestamp,
+  PgTimestampString,
+  PgUUID
+} from "drizzle-orm/pg-core";
+import {
+  sql as sql3
+} from "drizzle-orm";
+
+class DuckDBDialect extends PgDialect {
+  static [entityKind2] = "DuckDBPgDialect";
+  async migrate(migrations, session, config) {
+    const migrationsSchema = config.migrationsSchema ?? "drizzle";
+    const migrationsTable = config.migrationsTable ?? "__drizzle_migrations";
+    const migrationTableCreate = sql3`
+			CREATE TABLE IF NOT EXISTS ${sql3.identifier(migrationsSchema)}.${sql3.identifier(migrationsTable)} (
+				id integer PRIMARY KEY default nextval('migrations_pk_seq'),
+				hash text NOT NULL,
+				created_at bigint
+			)
+		`;
+    await session.execute(sql3.raw("CREATE SEQUENCE IF NOT EXISTS migrations_pk_seq"));
+    await session.execute(sql3`CREATE SCHEMA IF NOT EXISTS ${sql3.identifier(migrationsSchema)}`);
+    await session.execute(migrationTableCreate);
+    const dbMigrations = await session.all(sql3`select id, hash, created_at from ${sql3.identifier(migrationsSchema)}.${sql3.identifier(migrationsTable)} order by created_at desc limit 1`);
+    const lastDbMigration = dbMigrations[0];
+    await session.transaction(async (tx) => {
+      for await (const migration of migrations) {
+        if (!lastDbMigration || Number(lastDbMigration.created_at) < migration.folderMillis) {
+          for (const stmt of migration.sql) {
+            await tx.execute(sql3.raw(stmt));
+          }
+          await tx.execute(sql3`insert into ${sql3.identifier(migrationsSchema)}.${sql3.identifier(migrationsTable)} ("hash", "created_at") values(${migration.hash}, ${migration.folderMillis})`);
+        }
+      }
+    });
+  }
+  prepareTyping(encoder) {
+    if (is2(encoder, PgJsonb) || is2(encoder, PgJson)) {
+      throw new Error("JSON and JSONB types are not supported in DuckDB");
+    } else if (is2(encoder, PgNumeric)) {
+      return "decimal";
+    } else if (is2(encoder, PgTime)) {
+      return "time";
+    } else if (is2(encoder, PgTimestamp) || is2(encoder, PgTimestampString)) {
+      return "timestamp";
+    } else if (is2(encoder, PgDate) || is2(encoder, PgDateString)) {
+      return "date";
+    } else if (is2(encoder, PgUUID)) {
+      return "uuid";
+    } else {
+      return "none";
+    }
+  }
+}
+
+// src/driver.ts
+import {
+  PgSelectBase,
+  PgSelectBuilder
+} from "drizzle-orm/pg-core/query-builders";
+import { SQL as SQL3 } from "drizzle-orm/sql/sql";
+import { Subquery, ViewBaseConfig } from "drizzle-orm";
+import { PgViewBase } from "drizzle-orm/pg-core/view-base";
+class DuckDBDriver {
+  client;
+  dialect;
+  options;
+  static [entityKind3] = "DuckDBDriver";
+  constructor(client, dialect, options = {}) {
+    this.client = client;
+    this.dialect = dialect;
+    this.options = options;
+  }
+  createSession(schema) {
+    return new DuckDBSession(this.client, this.dialect, schema, {
+      logger: this.options.logger
+    });
+  }
+}
+function drizzle(client, config = {}) {
+  const dialect = new DuckDBDialect;
+  const logger = config.logger === true ? new DefaultLogger : config.logger || undefined;
+  let schema;
+  if (config.schema) {
+    const tablesConfig = extractTablesRelationalConfig(config.schema, createTableRelationsHelpers);
+    schema = {
+      fullSchema: config.schema,
+      schema: tablesConfig.tables,
+      tableNamesMap: tablesConfig.tableNamesMap
+    };
+  }
+  const driver = new DuckDBDriver(client, dialect, { logger });
+  const session = driver.createSession(schema);
+  return new DuckDBDatabase(dialect, session, schema);
+}
+
+class DuckDBDatabase extends PgDatabase {
+  dialect;
+  session;
+  static [entityKind3] = "DuckDBDatabase";
+  constructor(dialect, session, schema) {
+    super(dialect, session, schema);
+    this.dialect = dialect;
+    this.session = session;
+  }
+  select(fields) {
+    if (!fields) {
+      return new DuckDBSelectBuilder({
+        fields: fields ?? undefined,
+        session: this.session,
+        dialect: this.dialect
+      });
+    }
+    const aliasedFields = aliasFields(fields);
+    return new DuckDBSelectBuilder({
+      fields: aliasedFields,
+      session: this.session,
+      dialect: this.dialect
+    });
+  }
+  async transaction(transaction) {
+    return await this.session.transaction(transaction);
+  }
+}
+
+class DuckDBSelectBuilder extends PgSelectBuilder {
+  _fields;
+  _session;
+  _dialect;
+  _withList = [];
+  _distinct;
+  constructor(config) {
+    super(config);
+    this._fields = config.fields;
+    this._session = config.session;
+    this._dialect = config.dialect;
+    if (config.withList) {
+      this._withList = config.withList;
+    }
+    this._distinct = config.distinct;
+  }
+  from(source) {
+    const isPartialSelect = !!this._fields;
+    const src = source;
+    let fields;
+    if (this._fields) {
+      fields = this._fields;
+    } else if (is3(src, Subquery)) {
+      fields = Object.fromEntries(Object.keys(src._.selectedFields).map((key) => [
+        key,
+        src[key]
+      ]));
+    } else if (is3(src, PgViewBase)) {
+      fields = src[ViewBaseConfig]?.selectedFields;
+    } else if (is3(src, SQL3)) {
+      fields = {};
+    } else {
+      fields = aliasFields(getTableColumns(src), !isPartialSelect);
+    }
+    return new PgSelectBase({
+      table: src,
+      fields,
+      isPartialSelect,
+      session: this._session,
+      dialect: this._dialect,
+      withList: this._withList,
+      distinct: this._distinct
+    });
+  }
+}
+export {
+  drizzle,
+  DuckDBTransaction,
+  DuckDBSession,
+  DuckDBSelectBuilder,
+  DuckDBPreparedQuery,
+  DuckDBDriver,
+  DuckDBDatabase
+};

package/package.json

@@ -1,25 +1,27 @@
 {
   "name": "@duckdbfan/drizzle-duckdb",
   "module": "index.ts",
-  "main": "dist/index.js",
+  "main": "dist/index.mjs",
   "types": "dist/index.d.ts",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "A drizzle ORM client for use with DuckDB. Based on drizzle's Postgres client.",
   "type": "module",
   "scripts": {
-    "build": "bun build --target=node ./src/index.ts --outfile=dist/index.js && bun run build:declarations",
+    "build": "bun build --target=node ./src/index.ts --outfile=./dist/index.mjs --packages=external && bun run build:declarations",
     "build:declarations": "tsc --emitDeclarationOnly --project tsconfig.types.json",
     "test": "vitest",
     "t": "vitest --watch --ui"
   },
-  "dependencies": {
-    "drizzle-orm": "0.40.0",
-    "duckdb-async": "^1.2.0"
+  "peerDependencies": {
+    "drizzle-orm": "^0.40.0",
+    "duckdb-async": "^1.0.0"
   },
   "devDependencies": {
     "@types/bun": "^1.2.5",
     "@types/uuid": "^10.0.0",
     "@vitest/ui": "^1.6.0",
+    "drizzle-orm": "0.40.0",
+    "duckdb-async": "^1.2.0",
     "prettier": "^3.5.3",
     "typescript": "^5.8.2",
     "uuid": "^10.0.0",
@@ -41,7 +43,7 @@
   "homepage": "https://github.com/duckdbfan/drizzle-duckdb#readme",
   "files": [
     "src/*.ts",
-    "dist/*.js",
+    "dist/*.mjs",
     "dist/*.d.ts"
   ]
 }