@leonardovida-md/drizzle-neo-duckdb 1.0.3 → 1.1.1

package/src/sql/query-rewriters.ts

@@ -1,144 +1,205 @@
-const selectionRegex = /select\s+(.+)\s+from/i;
-const tableIdPropSelectionRegex = new RegExp(
-  [
-    `("(.+)"\\."(.+)")`, // table identifier + property
-    `(\\s+as\\s+'?(.+?)'?\\.'?(.+?)'?)?`, // optional AS clause
-  ].join(''),
-  'i'
-);
-const noTableIdPropSelectionRegex = /"(.+)"(\s+as\s+'?\1'?)?/i;
+type ArrayOperator = {
+  token: '@>' | '<@' | '&&';
+  fn: 'array_has_all' | 'array_has_any';
+  swap?: boolean;
+};
+
+const OPERATORS: ArrayOperator[] = [
+  { token: '@>', fn: 'array_has_all' },
+  { token: '<@', fn: 'array_has_all', swap: true },
+  { token: '&&', fn: 'array_has_any' },
+];
+
+const isWhitespace = (char: string | undefined) =>
+  char !== undefined && /\s/.test(char);
+
+export function scrubForRewrite(query: string): string {
+  let scrubbed = '';
+  type State = 'code' | 'single' | 'double' | 'lineComment' | 'blockComment';
+  let state: State = 'code';
+
+  for (let i = 0; i < query.length; i += 1) {
+    const char = query[i]!;
+    const next = query[i + 1];
+
+    if (state === 'code') {
+      if (char === "'") {
+        scrubbed += "'";
+        state = 'single';
+        continue;
+      }
+      if (char === '"') {
+        scrubbed += '"';
+        state = 'double';
+        continue;
+      }
+      if (char === '-' && next === '-') {
+        scrubbed += '  ';
+        i += 1;
+        state = 'lineComment';
+        continue;
+      }
+      if (char === '/' && next === '*') {
+        scrubbed += '  ';
+        i += 1;
+        state = 'blockComment';
+        continue;
+      }
 
-export function adaptArrayOperators(query: string): string {
-  type ArrayOperator = {
-    token: '@>' | '<@' | '&&';
-    fn: 'array_has_all' | 'array_has_any';
-    swap?: boolean;
-  };
-
-  const operators: ArrayOperator[] = [
-    { token: '@>', fn: 'array_has_all' },
-    { token: '<@', fn: 'array_has_all', swap: true },
-    { token: '&&', fn: 'array_has_any' },
-  ];
-
-  const isWhitespace = (char: string | undefined) =>
-    char !== undefined && /\s/.test(char);
-
-  const walkLeft = (source: string, start: number): [number, string] => {
-    let idx = start;
-    while (idx >= 0 && isWhitespace(source[idx])) {
-      idx--;
+      scrubbed += char;
+      continue;
     }
 
-    let depth = 0;
-    let inString = false;
-    for (; idx >= 0; idx--) {
-      const ch = source[idx];
-      if (ch === "'" && source[idx - 1] !== '\\') {
-        inString = !inString;
+    if (state === 'single') {
+      if (char === "'" && next === "'") {
+        scrubbed += "''";
+        i += 1;
+        continue;
       }
-      if (inString) continue;
-      if (ch === ')' || ch === ']') {
-        depth++;
-      } else if (ch === '(' || ch === '[') {
-        depth--;
-        if (depth < 0) {
-          return [idx + 1, source.slice(idx + 1, start + 1)];
-        }
-      } else if (depth === 0 && isWhitespace(ch)) {
-        return [idx + 1, source.slice(idx + 1, start + 1)];
+      // Preserve quote for boundary detection but mask inner chars with a
+      // non-whitespace placeholder to avoid false positives on operators.
+      scrubbed += char === "'" ? "'" : '.';
+      if (char === "'") {
+        state = 'code';
       }
+      continue;
     }
-    return [0, source.slice(0, start + 1)];
-  };
 
-  const walkRight = (source: string, start: number): [number, string] => {
-    let idx = start;
-    while (idx < source.length && isWhitespace(source[idx])) {
-      idx++;
+    if (state === 'double') {
+      if (char === '"' && next === '"') {
+        scrubbed += '""';
+        i += 1;
+        continue;
+      }
+      scrubbed += char === '"' ? '"' : '.';
+      if (char === '"') {
+        state = 'code';
+      }
+      continue;
     }
 
-    let depth = 0;
-    let inString = false;
-    for (; idx < source.length; idx++) {
-      const ch = source[idx];
-      if (ch === "'" && source[idx - 1] !== '\\') {
-        inString = !inString;
-      }
-      if (inString) continue;
-      if (ch === '(' || ch === '[') {
-        depth++;
-      } else if (ch === ')' || ch === ']') {
-        depth--;
-        if (depth < 0) {
-          return [idx, source.slice(start, idx)];
-        }
-      } else if (depth === 0 && isWhitespace(ch)) {
-        return [idx, source.slice(start, idx)];
+    if (state === 'lineComment') {
+      scrubbed += char === '\n' ? '\n' : ' ';
+      if (char === '\n') {
+        state = 'code';
       }
+      continue;
     }
-    return [source.length, source.slice(start)];
-  };
 
-  let rewritten = query;
-  for (const { token, fn, swap } of operators) {
-    let idx = rewritten.indexOf(token);
-    while (idx !== -1) {
-      const [leftStart, leftExpr] = walkLeft(rewritten, idx - 1);
-      const [rightEnd, rightExpr] = walkRight(rewritten, idx + token.length);
+    if (state === 'blockComment') {
+      if (char === '*' && next === '/') {
+        scrubbed += '  ';
+        i += 1;
+        state = 'code';
+      } else {
+        scrubbed += ' ';
+      }
+    }
+  }
 
-      const left = leftExpr.trim();
-      const right = rightExpr.trim();
+  return scrubbed;
+}
 
-      const replacement = `${fn}(${swap ? right : left}, ${
-        swap ? left : right
-      })`;
+function findNextOperator(
+  scrubbed: string,
+  start: number
+): { index: number; operator: ArrayOperator } | null {
+  for (let idx = start; idx < scrubbed.length; idx += 1) {
+    for (const operator of OPERATORS) {
+      if (scrubbed.startsWith(operator.token, idx)) {
+        return { index: idx, operator };
+      }
+    }
+  }
+  return null;
+}
 
-      rewritten =
-        rewritten.slice(0, leftStart) + replacement + rewritten.slice(rightEnd);
+function walkLeft(
+  source: string,
+  scrubbed: string,
+  start: number
+): [number, string] {
+  let idx = start;
+  while (idx >= 0 && isWhitespace(scrubbed[idx])) {
+    idx -= 1;
+  }
 
-      idx = rewritten.indexOf(token, leftStart + replacement.length);
+  let depth = 0;
+  for (; idx >= 0; idx -= 1) {
+    const ch = scrubbed[idx];
+    if (ch === ')' || ch === ']') {
+      depth += 1;
+    } else if (ch === '(' || ch === '[') {
+      if (depth === 0) {
+        return [idx + 1, source.slice(idx + 1, start + 1)];
+      }
+      depth = Math.max(0, depth - 1);
+    } else if (depth === 0 && isWhitespace(ch)) {
+      return [idx + 1, source.slice(idx + 1, start + 1)];
     }
   }
 
-  return rewritten;
+  return [0, source.slice(0, start + 1)];
 }
 
-export function queryAdapter(query: string): string {
-  const selection = selectionRegex.exec(query);
-
-  if (selection?.length !== 2) {
-    return query;
+function walkRight(
+  source: string,
+  scrubbed: string,
+  start: number
+): [number, string] {
+  let idx = start;
+  while (idx < scrubbed.length && isWhitespace(scrubbed[idx])) {
+    idx += 1;
   }
 
-  const fields = selection[1]
-    .split(',')
-    .map((field) => {
-      const trimmedField = field.trim();
-      const tableProp = tableIdPropSelectionRegex.exec(trimmedField);
-      if (tableProp) {
-        const [, identifier, table, column, , aliasTable, aliasColumn] =
-          tableProp;
-
-        const asAlias = `'${aliasTable ?? table}.${aliasColumn ?? column}'`;
-        if (tableProp[4]) {
-          return trimmedField.replace(tableProp[4], ` as ${asAlias}`);
-        }
-        return `${identifier} as ${asAlias}`;
+  let depth = 0;
+  for (; idx < scrubbed.length; idx += 1) {
+    const ch = scrubbed[idx];
+    if (ch === '(' || ch === '[') {
+      depth += 1;
+    } else if (ch === ')' || ch === ']') {
+      if (depth === 0) {
+        return [idx, source.slice(start, idx)];
       }
+      depth = Math.max(0, depth - 1);
+    } else if (depth === 0 && isWhitespace(ch)) {
+      return [idx, source.slice(start, idx)];
+    }
+  }
 
-      const noTableProp = noTableIdPropSelectionRegex.exec(trimmedField);
-      if (noTableProp) {
-        const [, column, alias] = noTableProp;
-        const asAlias = ` as '${column}'`;
-        return alias
-          ? trimmedField.replace(alias, asAlias)
-          : `${trimmedField}${asAlias}`;
-      }
+  return [scrubbed.length, source.slice(start)];
+}
 
-      return trimmedField;
-    })
-    .filter(Boolean) as string[];
+export function adaptArrayOperators(query: string): string {
+  let rewritten = query;
+  let scrubbed = scrubForRewrite(query);
+  let searchStart = 0;
+
+  // Re-run after each replacement to keep indexes aligned with the current string
+  while (true) {
+    const next = findNextOperator(scrubbed, searchStart);
+    if (!next) break;
+
+    const { index, operator } = next;
+    const [leftStart, leftExpr] = walkLeft(rewritten, scrubbed, index - 1);
+    const [rightEnd, rightExpr] = walkRight(
+      rewritten,
+      scrubbed,
+      index + operator.token.length
+    );
+
+    const left = leftExpr.trim();
+    const right = rightExpr.trim();
+
+    const replacement = `${operator.fn}(${operator.swap ? right : left}, ${
+      operator.swap ? left : right
+    })`;
+
+    rewritten =
+      rewritten.slice(0, leftStart) + replacement + rewritten.slice(rightEnd);
+    scrubbed = scrubForRewrite(rewritten);
+    searchStart = leftStart + replacement.length;
+  }
 
-  return query.replace(selection[1], fields.join(', '));
+  return rewritten;
 }

package/src/sql/result-mapper.ts

@@ -32,7 +32,7 @@ function toDecoderInput<TDecoder extends DriverValueDecoder<unknown, unknown>>(
   return value as DecoderInput<TDecoder>;
 }
 
-function normalizeInet(value: unknown): unknown {
+export function normalizeInet(value: unknown): unknown {
   if (
     value &&
     typeof value === 'object' &&
@@ -70,7 +70,7 @@ function normalizeInet(value: unknown): unknown {
   return value;
 }
 
-function normalizeTimestampString(
+export function normalizeTimestampString(
   value: unknown,
   withTimezone: boolean
 ): string | unknown {
@@ -88,7 +88,7 @@ function normalizeTimestampString(
   return value;
 }
 
-function normalizeTimestamp(
+export function normalizeTimestamp(
   value: unknown,
   withTimezone: boolean
 ): Date | unknown {
@@ -105,7 +105,7 @@ function normalizeTimestamp(
   return value;
 }
 
-function normalizeDateString(value: unknown): string | unknown {
+export function normalizeDateString(value: unknown): string | unknown {
   if (value instanceof Date) {
     return value.toISOString().slice(0, 10);
   }
@@ -115,7 +115,7 @@ function normalizeDateString(value: unknown): string | unknown {
   return value;
 }
 
-function normalizeDateValue(value: unknown): Date | unknown {
+export function normalizeDateValue(value: unknown): Date | unknown {
   if (value instanceof Date) {
     return value;
   }
@@ -125,7 +125,7 @@ function normalizeDateValue(value: unknown): Date | unknown {
   return value;
 }
 
-function normalizeTime(value: unknown): string | unknown {
+export function normalizeTime(value: unknown): string | unknown {
   if (typeof value === 'bigint') {
     const totalMillis = Number(value) / 1000;
     const date = new Date(totalMillis);
@@ -137,7 +137,7 @@ function normalizeTime(value: unknown): string | unknown {
   return value;
 }
 
-function normalizeInterval(value: unknown): string | unknown {
+export function normalizeInterval(value: unknown): string | unknown {
   if (
     value &&
     typeof value === 'object' &&

package/src/utils.ts

@@ -1,3 +1,3 @@
 export { aliasFields } from './sql/selection.ts';
-export { adaptArrayOperators, queryAdapter } from './sql/query-rewriters.ts';
+export { adaptArrayOperators } from './sql/query-rewriters.ts';
 export { mapResultRow } from './sql/result-mapper.ts';

package/src/value-wrappers-core.ts

@@ -0,0 +1,156 @@
+/**
+ * DuckDB wrapper value helpers that are safe for client-side bundles.
+ * These utilities only tag values; conversion to native bindings lives
+ * in value-wrappers.ts to avoid pulling @duckdb/node-api into browsers.
+ */
+export const DUCKDB_VALUE_MARKER = Symbol.for('drizzle-duckdb:value');
+
+export type DuckDBValueKind =
+  | 'list'
+  | 'array'
+  | 'struct'
+  | 'map'
+  | 'timestamp'
+  | 'blob'
+  | 'json';
+
+export interface DuckDBValueWrapper<
+  TKind extends DuckDBValueKind = DuckDBValueKind,
+  TData = unknown,
+> {
+  readonly [DUCKDB_VALUE_MARKER]: true;
+  readonly kind: TKind;
+  readonly data: TData;
+}
+
+export interface ListValueWrapper
+  extends DuckDBValueWrapper<'list', unknown[]> {
+  readonly elementType?: string;
+}
+
+export interface ArrayValueWrapper
+  extends DuckDBValueWrapper<'array', unknown[]> {
+  readonly elementType?: string;
+  readonly fixedLength?: number;
+}
+
+export interface StructValueWrapper
+  extends DuckDBValueWrapper<'struct', Record<string, unknown>> {
+  readonly schema?: Record<string, string>;
+}
+
+export interface MapValueWrapper
+  extends DuckDBValueWrapper<'map', Record<string, unknown>> {
+  readonly valueType?: string;
+}
+
+export interface TimestampValueWrapper
+  extends DuckDBValueWrapper<'timestamp', Date | string | number | bigint> {
+  readonly withTimezone: boolean;
+  readonly precision?: number;
+}
+
+export interface BlobValueWrapper
+  extends DuckDBValueWrapper<'blob', Buffer | Uint8Array> {}
+
+export interface JsonValueWrapper extends DuckDBValueWrapper<'json', unknown> {}
+
+export type AnyDuckDBValueWrapper =
+  | ListValueWrapper
+  | ArrayValueWrapper
+  | StructValueWrapper
+  | MapValueWrapper
+  | TimestampValueWrapper
+  | BlobValueWrapper
+  | JsonValueWrapper;
+
+export function isDuckDBWrapper(
+  value: unknown
+): value is AnyDuckDBValueWrapper {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    DUCKDB_VALUE_MARKER in value &&
+    (value as DuckDBValueWrapper)[DUCKDB_VALUE_MARKER] === true
+  );
+}
+
+export function wrapList(
+  data: unknown[],
+  elementType?: string
+): ListValueWrapper {
+  return {
+    [DUCKDB_VALUE_MARKER]: true,
+    kind: 'list',
+    data,
+    elementType,
+  };
+}
+
+export function wrapArray(
+  data: unknown[],
+  elementType?: string,
+  fixedLength?: number
+): ArrayValueWrapper {
+  return {
+    [DUCKDB_VALUE_MARKER]: true,
+    kind: 'array',
+    data,
+    elementType,
+    fixedLength,
+  };
+}
+
+export function wrapStruct(
+  data: Record<string, unknown>,
+  schema?: Record<string, string>
+): StructValueWrapper {
+  return {
+    [DUCKDB_VALUE_MARKER]: true,
+    kind: 'struct',
+    data,
+    schema,
+  };
+}
+
+export function wrapMap(
+  data: Record<string, unknown>,
+  valueType?: string
+): MapValueWrapper {
+  return {
+    [DUCKDB_VALUE_MARKER]: true,
+    kind: 'map',
+    data,
+    valueType,
+  };
+}
+
+export function wrapTimestamp(
+  data: Date | string | number | bigint,
+  withTimezone: boolean,
+  precision?: number
+): TimestampValueWrapper {
+  return {
+    [DUCKDB_VALUE_MARKER]: true,
+    kind: 'timestamp',
+    data,
+    withTimezone,
+    precision,
+  };
+}
+
+export function wrapBlob(data: Buffer | Uint8Array): BlobValueWrapper {
+  return {
+    [DUCKDB_VALUE_MARKER]: true,
+    kind: 'blob',
+    data,
+  };
+}
+
+export function wrapJson(data: unknown): JsonValueWrapper {
+  return {
+    [DUCKDB_VALUE_MARKER]: true,
+    kind: 'json',
+    data,
+  };
+}