@duckdbfan/drizzle-duckdb 0.0.6 → 1.3.1

package/dist/helpers.d.ts

@@ -0,0 +1 @@
+export { duckDbList, duckDbArray, duckDbMap, duckDbStruct, duckDbJson, duckDbBlob, duckDbInet, duckDbInterval, duckDbTimestamp, duckDbDate, duckDbTime, duckDbArrayContains, duckDbArrayContained, duckDbArrayOverlaps, } from './columns.ts';

package/dist/helpers.mjs

@@ -0,0 +1,360 @@
+// src/columns.ts
+import { sql } from "drizzle-orm";
+import { customType } from "drizzle-orm/pg-core";
+
+// src/value-wrappers-core.ts
+var DUCKDB_VALUE_MARKER = Symbol.for("drizzle-duckdb:value");
+function wrapList(data, elementType) {
+  return {
+    [DUCKDB_VALUE_MARKER]: true,
+    kind: "list",
+    data,
+    elementType
+  };
+}
+function wrapArray(data, elementType, fixedLength) {
+  return {
+    [DUCKDB_VALUE_MARKER]: true,
+    kind: "array",
+    data,
+    elementType,
+    fixedLength
+  };
+}
+function wrapMap(data, valueType) {
+  return {
+    [DUCKDB_VALUE_MARKER]: true,
+    kind: "map",
+    data,
+    valueType
+  };
+}
+function wrapTimestamp(data, withTimezone, precision) {
+  return {
+    [DUCKDB_VALUE_MARKER]: true,
+    kind: "timestamp",
+    data,
+    withTimezone,
+    precision
+  };
+}
+function wrapBlob(data) {
+  return {
+    [DUCKDB_VALUE_MARKER]: true,
+    kind: "blob",
+    data
+  };
+}
+function wrapJson(data) {
+  return {
+    [DUCKDB_VALUE_MARKER]: true,
+    kind: "json",
+    data
+  };
+}
+
+// src/columns.ts
+function coerceArrayString(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return [];
+  }
+  if (trimmed.startsWith("[")) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+  }
+  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+    try {
+      const json = trimmed.replace(/{/g, "[").replace(/}/g, "]");
+      return JSON.parse(json);
+    } catch {
+      return;
+    }
+  }
+  return;
+}
+function formatLiteral(value, typeHint) {
+  if (value === null || value === undefined) {
+    return "NULL";
+  }
+  const upperType = typeHint?.toUpperCase() ?? "";
+  if (value instanceof Date) {
+    return `'${value.toISOString()}'`;
+  }
+  if (typeof value === "number" || typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "boolean") {
+    return value ? "TRUE" : "FALSE";
+  }
+  const str = typeof value === "string" ? value : JSON.stringify(value) ?? String(value);
+  const escaped = str.replace(/'/g, "''");
+  if (upperType.includes("CHAR") || upperType.includes("TEXT") || upperType.includes("STRING") || upperType.includes("VARCHAR")) {
+    return `'${escaped}'`;
+  }
+  return `'${escaped}'`;
+}
+function buildListLiteral(values, elementType) {
+  if (values.length === 0) {
+    return sql`[]`;
+  }
+  const chunks = values.map((v) => typeof v === "object" && !Array.isArray(v) ? sql`${v}` : sql.raw(formatLiteral(v, elementType)));
+  return sql`list_value(${sql.join(chunks, sql.raw(", "))})`;
+}
+function buildStructLiteral(value, schema) {
+  const parts = Object.entries(value).map(([key, val]) => {
+    const typeHint = schema?.[key];
+    if (Array.isArray(val)) {
+      const inner = typeof typeHint === "string" && typeHint.endsWith("[]") ? typeHint.slice(0, -2) : undefined;
+      return sql`${sql.identifier(key)} := ${buildListLiteral(val, inner)}`;
+    }
+    return sql`${sql.identifier(key)} := ${val}`;
+  });
+  return sql`struct_pack(${sql.join(parts, sql.raw(", "))})`;
+}
+function buildMapLiteral(value, valueType) {
+  const keys = Object.keys(value);
+  const vals = Object.values(value);
+  const keyList = buildListLiteral(keys, "TEXT");
+  const valList = buildListLiteral(vals, valueType?.endsWith("[]") ? valueType.slice(0, -2) : valueType);
+  return sql`map(${keyList}, ${valList})`;
+}
+var duckDbList = (name, elementType) => customType({
+  dataType() {
+    return `${elementType}[]`;
+  },
+  toDriver(value) {
+    return wrapList(value, elementType);
+  },
+  fromDriver(value) {
+    if (Array.isArray(value)) {
+      return value;
+    }
+    if (typeof value === "string") {
+      const parsed = coerceArrayString(value);
+      if (parsed !== undefined) {
+        return parsed;
+      }
+    }
+    return value;
+  }
+})(name);
+var duckDbArray = (name, elementType, fixedLength) => customType({
+  dataType() {
+    return fixedLength ? `${elementType}[${fixedLength}]` : `${elementType}[]`;
+  },
+  toDriver(value) {
+    return wrapArray(value, elementType, fixedLength);
+  },
+  fromDriver(value) {
+    if (Array.isArray(value)) {
+      return value;
+    }
+    if (typeof value === "string") {
+      const parsed = coerceArrayString(value);
+      if (parsed !== undefined) {
+        return parsed;
+      }
+    }
+    return value;
+  }
+})(name);
+var duckDbMap = (name, valueType) => customType({
+  dataType() {
+    return `MAP (STRING, ${valueType})`;
+  },
+  toDriver(value) {
+    if (Object.keys(value).length === 0) {
+      return buildMapLiteral(value, valueType);
+    }
+    return wrapMap(value, valueType);
+  },
+  fromDriver(value) {
+    return value;
+  }
+})(name);
+var duckDbStruct = (name, schema) => customType({
+  dataType() {
+    const fields = Object.entries(schema).map(([key, type]) => `${key} ${type}`);
+    return `STRUCT (${fields.join(", ")})`;
+  },
+  toDriver(value) {
+    return buildStructLiteral(value, schema);
+  },
+  fromDriver(value) {
+    if (typeof value === "string") {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+    return value;
+  }
+})(name);
+var duckDbJson = (name) => customType({
+  dataType() {
+    return "JSON";
+  },
+  toDriver(value) {
+    if (typeof value === "string") {
+      return value;
+    }
+    if (value !== null && typeof value === "object" && "queryChunks" in value) {
+      return value;
+    }
+    return wrapJson(value);
+  },
+  fromDriver(value) {
+    if (typeof value !== "string") {
+      return value;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return value;
+    }
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return value;
+    }
+  }
+})(name);
+var duckDbBlob = customType({
+  dataType() {
+    return "BLOB";
+  },
+  toDriver(value) {
+    return wrapBlob(value);
+  }
+});
+var duckDbInet = (name) => customType({
+  dataType() {
+    return "INET";
+  },
+  toDriver(value) {
+    return value;
+  }
+})(name);
+var duckDbInterval = (name) => customType({
+  dataType() {
+    return "INTERVAL";
+  },
+  toDriver(value) {
+    return value;
+  }
+})(name);
+function shouldBindTimestamp(options) {
+  const bindMode = options.bindMode ?? "auto";
+  if (bindMode === "bind")
+    return true;
+  if (bindMode === "literal")
+    return false;
+  const isBun = typeof process !== "undefined" && typeof process.versions?.bun !== "undefined";
+  if (isBun)
+    return false;
+  const forceLiteral = typeof process !== "undefined" ? process.env.DRIZZLE_DUCKDB_FORCE_LITERAL_TIMESTAMPS : undefined;
+  if (forceLiteral && forceLiteral !== "0") {
+    return false;
+  }
+  return true;
+}
+var duckDbTimestamp = (name, options = {}) => customType({
+  dataType() {
+    if (options.withTimezone) {
+      return "TIMESTAMPTZ";
+    }
+    const precision = options.precision ? `(${options.precision})` : "";
+    return `TIMESTAMP${precision}`;
+  },
+  toDriver(value) {
+    if (shouldBindTimestamp(options)) {
+      return wrapTimestamp(value, options.withTimezone ?? false, options.precision);
+    }
+    const iso = value instanceof Date ? value.toISOString() : value;
+    const normalized = iso.replace("T", " ").replace("Z", "+00");
+    const typeKeyword = options.withTimezone ? "TIMESTAMPTZ" : "TIMESTAMP";
+    return sql.raw(`${typeKeyword} '${normalized}'`);
+  },
+  fromDriver(value) {
+    if (value && typeof value === "object" && "kind" in value && value.kind === "timestamp") {
+      const wrapped = value;
+      return wrapped.data instanceof Date ? wrapped.data : typeof wrapped.data === "number" || typeof wrapped.data === "bigint" ? new Date(Number(wrapped.data) / 1000) : wrapped.data;
+    }
+    if (options.mode === "string") {
+      if (value instanceof Date) {
+        return value.toISOString().replace("T", " ").replace("Z", "+00");
+      }
+      return typeof value === "string" ? value : value.toString();
+    }
+    if (value instanceof Date) {
+      return value;
+    }
+    const stringValue = typeof value === "string" ? value : value.toString();
+    const hasOffset = stringValue.endsWith("Z") || /[+-]\d{2}:?\d{2}$/.test(stringValue);
+    const normalized = hasOffset ? stringValue.replace(" ", "T") : `${stringValue.replace(" ", "T")}Z`;
+    return new Date(normalized);
+  }
+})(name);
+var duckDbDate = (name) => customType({
+  dataType() {
+    return "DATE";
+  },
+  toDriver(value) {
+    return value;
+  },
+  fromDriver(value) {
+    const str = value instanceof Date ? value.toISOString().slice(0, 10) : value;
+    return str;
+  }
+})(name);
+var duckDbTime = (name) => customType({
+  dataType() {
+    return "TIME";
+  },
+  toDriver(value) {
+    return value;
+  },
+  fromDriver(value) {
+    if (typeof value === "bigint") {
+      const totalMillis = Number(value) / 1000;
+      const date = new Date(totalMillis);
+      return date.toISOString().split("T")[1].replace("Z", "");
+    }
+    return value;
+  }
+})(name);
+function toListValue(values) {
+  return buildListLiteral(values);
+}
+function duckDbArrayContains(column, values) {
+  const rhs = Array.isArray(values) ? toListValue(values) : values;
+  return sql`array_has_all(${column}, ${rhs})`;
+}
+function duckDbArrayContained(column, values) {
+  const rhs = Array.isArray(values) ? toListValue(values) : values;
+  return sql`array_has_all(${rhs}, ${column})`;
+}
+function duckDbArrayOverlaps(column, values) {
+  const rhs = Array.isArray(values) ? toListValue(values) : values;
+  return sql`array_has_any(${column}, ${rhs})`;
+}
+export {
+  duckDbTimestamp,
+  duckDbTime,
+  duckDbStruct,
+  duckDbMap,
+  duckDbList,
+  duckDbJson,
+  duckDbInterval,
+  duckDbInet,
+  duckDbDate,
+  duckDbBlob,
+  duckDbArrayOverlaps,
+  duckDbArrayContains,
+  duckDbArrayContained,
+  duckDbArray
+};

package/dist/index.d.ts

@@ -2,3 +2,10 @@ export * from './driver.ts';
 export * from './session.ts';
 export * from './columns.ts';
 export * from './migrator.ts';
+export * from './introspect.ts';
+export * from './client.ts';
+export * from './pool.ts';
+export * from './olap.ts';
+export * from './value-wrappers.ts';
+export * from './options.ts';
+export * from './operators.ts';