@farming-labs/orm-sql 0.0.10 → 0.0.12

package/dist/index.js

@@ -3,11 +3,13 @@ import { randomUUID } from "crypto";
 import {
   createManifest,
   mergeUniqueLookupCreateData,
+  isOperatorFilterObject,
   requireUniqueLookup,
   resolveRowIdentityLookup,
   toUniqueLookupWhere,
   validateUniqueLookupUpdateData
 } from "@farming-labs/orm";
+var nativeNodeIdentity = /* @__PURE__ */ Symbol("nativeNodeIdentity");
 var manifestCache = /* @__PURE__ */ new WeakMap();
 function getManifest(schema) {
   const cached = manifestCache.get(schema);
@@ -56,6 +58,9 @@ function encodeValue(field, dialect, value) {
     if (dialect === "postgres") return Boolean(value);
     return value ? 1 : 0;
   }
+  if (field.kind === "integer") {
+    return Number(value);
+  }
   if (field.kind === "datetime") {
     if (value instanceof Date) {
       if (dialect === "mysql") {
@@ -65,6 +70,12 @@ function encodeValue(field, dialect, value) {
     }
     return value;
   }
+  if (field.kind === "json") {
+    if (dialect === "postgres") {
+      return value;
+    }
+    return JSON.stringify(value);
+  }
   return value;
 }
 function normalizeNaiveSqlDate(value) {
@@ -108,6 +119,19 @@ function decodeValue(field, dialect, value) {
     }
     return new Date(String(value));
   }
+  if (field.kind === "integer") {
+    return typeof value === "number" ? value : Number(value);
+  }
+  if (field.kind === "json") {
+    if (typeof value === "string") {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+    return value;
+  }
   return value;
 }
 function decodeRow(model, dialect, row) {
@@ -125,39 +149,36 @@ function mergeWhere(...clauses) {
     AND: defined
   };
 }
-function isFilterObject(value) {
-  return !!value && typeof value === "object" && !(value instanceof Date) && !Array.isArray(value);
-}
-function compileFieldFilter(model, fieldName, filter, dialect, state) {
+function compileFieldFilter(model, fieldName, filter, dialect, state, tableAlias = model.table) {
   const field = model.fields[fieldName];
   if (!field) {
     throw new Error(`Unknown field "${fieldName}" on model "${model.name}".`);
   }
-  const column = `${quoteIdentifier(model.table, dialect)}.${quoteIdentifier(field.column, dialect)}`;
-  if (!isFilterObject(filter)) {
+  const column = `${quoteIdentifier(tableAlias, dialect)}.${quoteIdentifier(field.column, dialect)}`;
+  const createValueExpression = (value) => {
+    const placeholder = createPlaceholder(dialect, state, encodeValue(field, dialect, value));
+    if (field.kind === "json" && dialect === "mysql") {
+      return `cast(${placeholder} as json)`;
+    }
+    return placeholder;
+  };
+  if (!isOperatorFilterObject(filter)) {
     if (filter === null) return `${column} is null`;
-    const placeholder = createPlaceholder(dialect, state, encodeValue(field, dialect, filter));
-    return `${column} = ${placeholder}`;
+    return `${column} = ${createValueExpression(filter)}`;
   }
   const clauses = [];
   if ("eq" in filter) {
     if (filter.eq === null) {
       clauses.push(`${column} is null`);
     } else {
-      const placeholder = createPlaceholder(dialect, state, encodeValue(field, dialect, filter.eq));
-      clauses.push(`${column} = ${placeholder}`);
+      clauses.push(`${column} = ${createValueExpression(filter.eq)}`);
     }
   }
   if ("not" in filter) {
     if (filter.not === null) {
       clauses.push(`${column} is not null`);
     } else {
-      const placeholder = createPlaceholder(
-        dialect,
-        state,
-        encodeValue(field, dialect, filter.not)
-      );
-      clauses.push(`${column} <> ${placeholder}`);
+      clauses.push(`${column} <> ${createValueExpression(filter.not)}`);
     }
   }
   if ("in" in filter) {
@@ -165,9 +186,7 @@ function compileFieldFilter(model, fieldName, filter, dialect, state) {
     if (!values.length) {
       clauses.push("1 = 0");
     } else {
-      const placeholders = values.map(
-        (value) => createPlaceholder(dialect, state, encodeValue(field, dialect, value))
-      );
+      const placeholders = values.map((value) => createValueExpression(value));
       clauses.push(`${column} in (${placeholders.join(", ")})`);
     }
   }
@@ -197,39 +216,39 @@ function compileFieldFilter(model, fieldName, filter, dialect, state) {
   if (clauses.length === 1) return clauses[0];
   return `(${clauses.join(" and ")})`;
 }
-function compileWhere(model, where, dialect, state) {
+function compileWhere(model, where, dialect, state, tableAlias = model.table) {
   if (!where) return void 0;
   const clauses = [];
   for (const [key, value] of Object.entries(where)) {
     if (key === "AND") {
       const items = Array.isArray(value) ? value : [];
       if (!items.length) continue;
-      const nested = items.map((item) => compileWhere(model, item, dialect, state)).filter(Boolean).map((item) => `(${item})`);
+      const nested = items.map((item) => compileWhere(model, item, dialect, state, tableAlias)).filter(Boolean).map((item) => `(${item})`);
       if (nested.length) clauses.push(nested.join(" and "));
       continue;
     }
     if (key === "OR") {
       const items = Array.isArray(value) ? value : [];
       if (!items.length) continue;
-      const nested = items.map((item) => compileWhere(model, item, dialect, state)).filter(Boolean).map((item) => `(${item})`);
+      const nested = items.map((item) => compileWhere(model, item, dialect, state, tableAlias)).filter(Boolean).map((item) => `(${item})`);
       if (nested.length) clauses.push(`(${nested.join(" or ")})`);
       continue;
     }
     if (key === "NOT") {
-      const nested = compileWhere(model, value, dialect, state);
+      const nested = compileWhere(model, value, dialect, state, tableAlias);
       if (nested) clauses.push(`not (${nested})`);
       continue;
     }
-    clauses.push(compileFieldFilter(model, key, value, dialect, state));
+    clauses.push(compileFieldFilter(model, key, value, dialect, state, tableAlias));
   }
   if (!clauses.length) return void 0;
   return clauses.join(" and ");
 }
-function compileOrderBy(model, orderBy, dialect) {
+function compileOrderBy(model, orderBy, dialect, tableAlias = model.table) {
   if (!orderBy) return "";
   const parts = Object.entries(orderBy).filter(([fieldName]) => fieldName in model.fields).map(([fieldName, direction]) => {
     const field = model.fields[fieldName];
-    return `${quoteIdentifier(model.table, dialect)}.${quoteIdentifier(field.column, dialect)} ${direction === "desc" ? "desc" : "asc"}`;
+    return `${quoteIdentifier(tableAlias, dialect)}.${quoteIdentifier(field.column, dialect)} ${direction === "desc" ? "desc" : "asc"}`;
   });
   if (!parts.length) return "";
   return ` order by ${parts.join(", ")}`;
@@ -252,13 +271,14 @@ function compilePagination(dialect, take, skip) {
 }
 function buildSelectStatement(model, dialect, args) {
   const state = { params: [] };
+  const tableAlias = args.tableAlias ?? model.table;
   const selectList = Object.values(model.fields).map(
-    (field) => `${quoteIdentifier(model.table, dialect)}.${quoteIdentifier(field.column, dialect)} as ${quoteIdentifier(field.name, dialect)}`
+    (field) => `${quoteIdentifier(tableAlias, dialect)}.${quoteIdentifier(field.column, dialect)} as ${quoteIdentifier(field.name, dialect)}`
   );
-  let sql = `select ${selectList.join(", ")} from ${quoteIdentifier(model.table, dialect)}`;
-  const where = compileWhere(model, args.where, dialect, state);
+  let sql = `select ${selectList.join(", ")} from ${quoteIdentifier(model.table, dialect)} as ${quoteIdentifier(tableAlias, dialect)}`;
+  const where = compileWhere(model, args.where, dialect, state, tableAlias);
   if (where) sql += ` where ${where}`;
-  sql += compileOrderBy(model, args.orderBy, dialect);
+  sql += compileOrderBy(model, args.orderBy, dialect, tableAlias);
   sql += compilePagination(dialect, args.take, args.skip);
   return { sql, params: state.params };
 }
@@ -560,6 +580,10 @@ function createMysqlPoolAdapter(pool) {
 }
 function createSqlDriver(adapter) {
   async function loadRows(schema, modelName, args) {
+    const nativeRows = await loadRowsWithNativeJoins(schema, modelName, args);
+    if (nativeRows) {
+      return nativeRows;
+    }
     const manifest = getManifest(schema);
     const model = manifest.models[modelName];
     const statement = buildSelectStatement(model, adapter.dialect, args);
@@ -585,6 +609,253 @@ function createSqlDriver(adapter) {
     const row = result.rows[0];
     return row ? decodeRow(model, adapter.dialect, row) : null;
   }
+  function createNativePresenceAlias(model, alias, includeAllScalars, selectedScalarKeys) {
+    const occupiedAliases = new Set(
+      (includeAllScalars ? Object.keys(model.fields) : selectedScalarKeys).map(
+        (fieldName) => `${alias}__${fieldName}`
+      )
+    );
+    let candidate = `${alias}__orm_presence`;
+    let suffix = 0;
+    while (occupiedAliases.has(candidate)) {
+      suffix += 1;
+      candidate = `${alias}__orm_presence_${suffix}`;
+    }
+    return candidate;
+  }
+  function buildNativeJoinPlan(schema, modelName, select, aliasState) {
+    const manifest = getManifest(schema);
+    const model = manifest.models[modelName];
+    const alias = `t${aliasState.next++}`;
+    const entries = select ? Object.entries(select) : [];
+    const selectedScalarKeys = select ? entries.filter(([key, value]) => key in model.fields && value === true).map(([key]) => key) : Object.keys(model.fields);
+    const node = {
+      modelName,
+      model,
+      alias,
+      presenceAlias: createNativePresenceAlias(model, alias, !select, selectedScalarKeys),
+      includeAllScalars: !select,
+      selectedScalarKeys,
+      children: []
+    };
+    for (const [key, value] of entries) {
+      if (value === void 0 || !(key in schema.models[modelName].relations)) continue;
+      const relation = schema.models[modelName].relations[key];
+      const relationArgs = value === true ? {} : value;
+      if (relationArgs.where !== void 0 || relationArgs.orderBy !== void 0 || relationArgs.take !== void 0 || relationArgs.skip !== void 0) {
+        return null;
+      }
+      const child = buildNativeJoinPlan(
+        schema,
+        relation.target,
+        relationArgs.select,
+        aliasState
+      );
+      if (!child) return null;
+      child.relationName = key;
+      child.relationKind = relation.kind;
+      if (relation.kind === "belongsTo") {
+        const sourceField = model.fields[relation.foreignKey];
+        if (!sourceField) return null;
+        const targetReference = parseReference(sourceField.references);
+        const targetFieldName = targetReference?.field ?? identityField(manifest.models[relation.target]).name;
+        const targetField = child.model.fields[targetFieldName];
+        if (!targetField) return null;
+        child.sourceField = sourceField;
+        child.targetField = targetField;
+      } else if (relation.kind === "hasOne" || relation.kind === "hasMany") {
+        const targetForeignField = child.model.fields[relation.foreignKey];
+        if (!targetForeignField) return null;
+        const sourceReference = parseReference(targetForeignField.references);
+        const sourceFieldName = sourceReference?.field ?? identityField(manifest.models[modelName]).name;
+        const sourceField = model.fields[sourceFieldName];
+        if (!sourceField) return null;
+        child.sourceField = sourceField;
+        child.targetField = targetForeignField;
+      } else {
+        const throughModel = manifest.models[relation.through];
+        const throughFromField = throughModel.fields[relation.from];
+        const throughToField = throughModel.fields[relation.to];
+        if (!throughFromField || !throughToField) return null;
+        const throughFromReference = parseReference(throughFromField.references);
+        const throughToReference = parseReference(throughToField.references);
+        const sourceFieldName = throughFromReference?.field ?? identityField(manifest.models[modelName]).name;
+        const targetFieldName = throughToReference?.field ?? identityField(child.model).name;
+        const sourceField = model.fields[sourceFieldName];
+        const targetField = child.model.fields[targetFieldName];
+        if (!sourceField || !targetField) return null;
+        child.sourceField = sourceField;
+        child.targetField = targetField;
+        child.throughModel = throughModel;
+        child.throughAlias = `t${aliasState.next++}`;
+        child.throughFromField = throughFromField;
+        child.throughToField = throughToField;
+      }
+      node.children.push(child);
+    }
+    return node;
+  }
+  function hasNativeJoinableRelations(schema, modelName, select) {
+    if (!select) return false;
+    const plan = buildNativeJoinPlan(schema, modelName, select, { next: 0 });
+    return !!plan && plan.children.length > 0;
+  }
+  function collectNativeJoinSelects(node, selectList) {
+    const scalarKeys = node.includeAllScalars ? Object.keys(node.model.fields) : node.selectedScalarKeys;
+    for (const fieldName of scalarKeys) {
+      const field = node.model.fields[fieldName];
+      if (!field) continue;
+      selectList.push(
+        `${quoteIdentifier(node.alias, adapter.dialect)}.${quoteIdentifier(field.column, adapter.dialect)} as ${quoteIdentifier(`${node.alias}__${field.name}`, adapter.dialect)}`
+      );
+    }
+    const identity = identityField(node.model);
+    selectList.push(
+      `${quoteIdentifier(node.alias, adapter.dialect)}.${quoteIdentifier(identity.column, adapter.dialect)} as ${quoteIdentifier(node.presenceAlias, adapter.dialect)}`
+    );
+    for (const child of node.children) {
+      collectNativeJoinSelects(child, selectList);
+    }
+  }
+  function collectNativeJoinClauses(node, joins) {
+    for (const child of node.children) {
+      if (child.relationKind === "manyToMany") {
+        joins.push(
+          ` left join ${quoteIdentifier(child.throughModel.table, adapter.dialect)} as ${quoteIdentifier(child.throughAlias, adapter.dialect)} on ${quoteIdentifier(node.alias, adapter.dialect)}.${quoteIdentifier(child.sourceField.column, adapter.dialect)} = ${quoteIdentifier(child.throughAlias, adapter.dialect)}.${quoteIdentifier(child.throughFromField.column, adapter.dialect)}`
+        );
+        joins.push(
+          ` left join ${quoteIdentifier(child.model.table, adapter.dialect)} as ${quoteIdentifier(child.alias, adapter.dialect)} on ${quoteIdentifier(child.throughAlias, adapter.dialect)}.${quoteIdentifier(child.throughToField.column, adapter.dialect)} = ${quoteIdentifier(child.alias, adapter.dialect)}.${quoteIdentifier(child.targetField.column, adapter.dialect)}`
+        );
+      } else {
+        const leftColumn = child.relationKind === "belongsTo" ? `${quoteIdentifier(node.alias, adapter.dialect)}.${quoteIdentifier(child.sourceField.column, adapter.dialect)}` : `${quoteIdentifier(child.alias, adapter.dialect)}.${quoteIdentifier(child.targetField.column, adapter.dialect)}`;
+        const rightColumn = child.relationKind === "belongsTo" ? `${quoteIdentifier(child.alias, adapter.dialect)}.${quoteIdentifier(child.targetField.column, adapter.dialect)}` : `${quoteIdentifier(node.alias, adapter.dialect)}.${quoteIdentifier(child.sourceField.column, adapter.dialect)}`;
+        joins.push(
+          ` left join ${quoteIdentifier(child.model.table, adapter.dialect)} as ${quoteIdentifier(child.alias, adapter.dialect)} on ${leftColumn} = ${rightColumn}`
+        );
+      }
+      collectNativeJoinClauses(child, joins);
+    }
+  }
+  function buildNativeJoinRootSource(root, args) {
+    const state = { params: [] };
+    const sourceAlias = `${root.alias}__src`;
+    const selectList = Object.values(root.model.fields).map(
+      (field) => `${quoteIdentifier(sourceAlias, adapter.dialect)}.${quoteIdentifier(field.column, adapter.dialect)} as ${quoteIdentifier(field.column, adapter.dialect)}`
+    );
+    let sql = `select ${selectList.join(", ")} from ${quoteIdentifier(root.model.table, adapter.dialect)} as ${quoteIdentifier(sourceAlias, adapter.dialect)}`;
+    const where = compileWhere(root.model, args.where, adapter.dialect, state, sourceAlias);
+    if (where) sql += ` where ${where}`;
+    sql += compileOrderBy(root.model, args.orderBy, adapter.dialect, sourceAlias);
+    sql += compilePagination(adapter.dialect, args.take, args.skip);
+    return {
+      sql: `(${sql})`,
+      params: state.params
+    };
+  }
+  function buildNativeJoinStatement(root, args) {
+    const state = { params: [] };
+    const selectList = [];
+    const joins = [];
+    collectNativeJoinSelects(root, selectList);
+    collectNativeJoinClauses(root, joins);
+    const rootSource = buildNativeJoinRootSource(root, args);
+    state.params.push(...rootSource.params);
+    let sql = `select ${selectList.join(", ")} from ${rootSource.sql} as ${quoteIdentifier(root.alias, adapter.dialect)}`;
+    if (joins.length) sql += joins.join("");
+    sql += compileOrderBy(root.model, args.orderBy, adapter.dialect, root.alias);
+    return { sql, params: state.params };
+  }
+  function nodePresenceValue(node, rawRow) {
+    return rawRow[node.presenceAlias];
+  }
+  function projectNativeJoinNode(node, rawRow) {
+    if (nodePresenceValue(node, rawRow) == null) {
+      return null;
+    }
+    const output = {};
+    Object.defineProperty(output, nativeNodeIdentity, {
+      value: rawRow[node.presenceAlias],
+      enumerable: false,
+      configurable: true
+    });
+    const scalarKeys = node.includeAllScalars ? Object.keys(node.model.fields) : node.selectedScalarKeys;
+    for (const fieldName of scalarKeys) {
+      const field = node.model.fields[fieldName];
+      if (!field) continue;
+      output[field.name] = decodeValue(
+        field,
+        adapter.dialect,
+        rawRow[`${node.alias}__${field.name}`]
+      );
+    }
+    for (const child of node.children) {
+      const childValue = projectNativeJoinNode(child, rawRow);
+      output[child.relationName] = child.relationKind === "hasMany" || child.relationKind === "manyToMany" ? childValue ? [childValue] : [] : childValue;
+    }
+    return output;
+  }
+  function mergeNativeJoinNode(node, target, next) {
+    for (const child of node.children) {
+      const relationName = child.relationName;
+      if (child.relationKind === "hasMany" || child.relationKind === "manyToMany") {
+        const targetRows = Array.isArray(target[relationName]) ? target[relationName] : [];
+        const nextRows = Array.isArray(next[relationName]) ? next[relationName] : [];
+        if (!Array.isArray(target[relationName])) {
+          target[relationName] = targetRows;
+        }
+        for (const nextRow of nextRows) {
+          const identity = nextRow[nativeNodeIdentity];
+          const existing2 = targetRows.find((entry) => entry[nativeNodeIdentity] === identity);
+          if (existing2) {
+            mergeNativeJoinNode(child, existing2, nextRow);
+          } else {
+            targetRows.push(nextRow);
+          }
+        }
+        continue;
+      }
+      const nextValue = next[relationName];
+      if (nextValue === void 0) continue;
+      if (nextValue === null) {
+        if (!(relationName in target)) {
+          target[relationName] = null;
+        }
+        continue;
+      }
+      const existing = target[relationName];
+      if (!existing || typeof existing !== "object") {
+        target[relationName] = nextValue;
+        continue;
+      }
+      mergeNativeJoinNode(child, existing, nextValue);
+    }
+  }
+  async function loadRowsWithNativeJoins(schema, modelName, args) {
+    if (!hasNativeJoinableRelations(schema, modelName, args.select)) {
+      return null;
+    }
+    const plan = buildNativeJoinPlan(schema, modelName, args.select, { next: 0 });
+    if (!plan || !plan.children.length) {
+      return null;
+    }
+    const statement = buildNativeJoinStatement(plan, args);
+    const result = await adapter.query(statement.sql, statement.params);
+    const groupedRows = [];
+    const groupedByIdentity = /* @__PURE__ */ new Map();
+    for (const row of result.rows) {
+      const projected = projectNativeJoinNode(plan, row);
+      if (!projected) continue;
+      const identity = projected[nativeNodeIdentity];
+      const existing = groupedByIdentity.get(identity);
+      if (existing) {
+        mergeNativeJoinNode(plan, existing, projected);
+        continue;
+      }
+      groupedByIdentity.set(identity, projected);
+      groupedRows.push(projected);
+    }
+    return groupedRows;
+  }
   async function projectRow(schema, modelName, row, select) {
     const manifest = getManifest(schema);
     const model = manifest.models[modelName];