@farming-labs/orm-sql 0.0.1

package/dist/index.js

@@ -0,0 +1,900 @@
+// src/index.ts
+import { randomUUID } from "crypto";
+import {
+  createManifest
+} from "@farming-labs/orm";
+var manifestCache = /* @__PURE__ */ new WeakMap();
+function getManifest(schema) {
+  const cached = manifestCache.get(schema);
+  if (cached) return cached;
+  const next = createManifest(schema);
+  manifestCache.set(schema, next);
+  return next;
+}
+function quoteIdentifier(value, dialect) {
+  if (dialect === "mysql") {
+    return `\`${value.replace(/`/g, "``")}\``;
+  }
+  return `"${value.replace(/"/g, '""')}"`;
+}
+function createPlaceholder(dialect, state, value) {
+  state.params.push(value);
+  return dialect === "postgres" ? `$${state.params.length}` : "?";
+}
+function parseReference(reference) {
+  if (!reference) return null;
+  const [model, field] = reference.split(".");
+  if (!model || !field) return null;
+  return { model, field };
+}
+function identityField(model) {
+  if (model.fields.id) return model.fields.id;
+  const uniqueField = Object.values(model.fields).find((field) => field.unique);
+  if (uniqueField) return uniqueField;
+  throw new Error(
+    `Model "${model.name}" requires an "id" field or a unique field for the SQL runtime.`
+  );
+}
+function applyDefault(value, field) {
+  if (value !== void 0) return value;
+  if (field.generated === "id") return randomUUID();
+  if (field.generated === "now") return /* @__PURE__ */ new Date();
+  if (typeof field.defaultValue === "function") {
+    return field.defaultValue();
+  }
+  return field.defaultValue;
+}
+function encodeValue(field, dialect, value) {
+  if (value === void 0) return value;
+  if (value === null) return null;
+  if (field.kind === "boolean") {
+    if (dialect === "postgres") return Boolean(value);
+    return value ? 1 : 0;
+  }
+  if (field.kind === "datetime") {
+    return value instanceof Date ? value.toISOString() : value;
+  }
+  return value;
+}
+function decodeValue(field, value) {
+  if (value === void 0) return value;
+  if (value === null) return null;
+  if (field.kind === "boolean") {
+    if (typeof value === "boolean") return value;
+    if (typeof value === "number") return value !== 0;
+    if (typeof value === "string") {
+      return value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "t";
+    }
+  }
+  if (field.kind === "datetime") {
+    if (value instanceof Date) return value;
+    return new Date(String(value));
+  }
+  return value;
+}
+function decodeRow(model, row) {
+  const output = {};
+  for (const field of Object.values(model.fields)) {
+    output[field.name] = decodeValue(field, row[field.name]);
+  }
+  return output;
+}
+function mergeWhere(...clauses) {
+  const defined = clauses.filter(Boolean);
+  if (!defined.length) return void 0;
+  if (defined.length === 1) return defined[0];
+  return {
+    AND: defined
+  };
+}
+function isFilterObject(value) {
+  return !!value && typeof value === "object" && !(value instanceof Date) && !Array.isArray(value);
+}
+function extractEqualityValue(filter) {
+  if (!isFilterObject(filter)) {
+    return {
+      supported: true,
+      value: filter
+    };
+  }
+  const keys = Object.keys(filter);
+  if (keys.length === 1 && "eq" in filter) {
+    return {
+      supported: true,
+      value: filter.eq
+    };
+  }
+  return {
+    supported: false,
+    value: void 0
+  };
+}
+function extractUpsertConflict(model, where) {
+  const keys = Object.keys(where).filter((key) => key !== "AND" && key !== "OR" && key !== "NOT");
+  if ("AND" in where || "OR" in where || "NOT" in where || keys.length !== 1) {
+    throw new Error(
+      `Upsert on model "${model.name}" requires a single unique equality filter in "where".`
+    );
+  }
+  const fieldName = keys[0];
+  const field = model.fields[fieldName];
+  if (!field) {
+    throw new Error(`Unknown field "${fieldName}" on model "${model.name}".`);
+  }
+  if (!(field.kind === "id" || field.unique)) {
+    throw new Error(
+      `Upsert on model "${model.name}" requires the "where" field "${fieldName}" to be unique or an id field.`
+    );
+  }
+  const { supported, value } = extractEqualityValue(where[fieldName]);
+  if (!supported || value === void 0 || value === null) {
+    throw new Error(
+      `Upsert on model "${model.name}" requires the "where" field "${fieldName}" to use a single non-null equality value.`
+    );
+  }
+  return {
+    field,
+    value
+  };
+}
+function mergeUpsertCreateData(model, createData, conflict) {
+  const currentValue = createData[conflict.field.name];
+  if (currentValue !== void 0 && currentValue !== conflict.value) {
+    throw new Error(
+      `Upsert on model "${model.name}" requires create.${conflict.field.name} to match where.${conflict.field.name}.`
+    );
+  }
+  return {
+    ...createData,
+    [conflict.field.name]: currentValue ?? conflict.value
+  };
+}
+function validateUpsertUpdateData(model, updateData, conflict) {
+  const nextValue = updateData[conflict.field.name];
+  if (nextValue !== void 0 && nextValue !== conflict.value) {
+    throw new Error(
+      `Upsert on model "${model.name}" cannot change the conflict field "${conflict.field.name}".`
+    );
+  }
+}
+function compileFieldFilter(model, fieldName, filter, dialect, state) {
+  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)) {
+    if (filter === null) return `${column} is null`;
+    const placeholder = createPlaceholder(dialect, state, encodeValue(field, dialect, filter));
+    return `${column} = ${placeholder}`;
+  }
+  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}`);
+    }
+  }
+  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}`);
+    }
+  }
+  if ("in" in filter) {
+    const values = Array.isArray(filter.in) ? filter.in : [];
+    if (!values.length) {
+      clauses.push("1 = 0");
+    } else {
+      const placeholders = values.map(
+        (value) => createPlaceholder(dialect, state, encodeValue(field, dialect, value))
+      );
+      clauses.push(`${column} in (${placeholders.join(", ")})`);
+    }
+  }
+  if ("contains" in filter) {
+    const placeholder = createPlaceholder(dialect, state, String(filter.contains ?? ""));
+    clauses.push(
+      dialect === "postgres" ? `strpos(${column}, ${placeholder}) > 0` : `instr(${column}, ${placeholder}) > 0`
+    );
+  }
+  if ("gt" in filter) {
+    const placeholder = createPlaceholder(dialect, state, encodeValue(field, dialect, filter.gt));
+    clauses.push(`${column} > ${placeholder}`);
+  }
+  if ("gte" in filter) {
+    const placeholder = createPlaceholder(dialect, state, encodeValue(field, dialect, filter.gte));
+    clauses.push(`${column} >= ${placeholder}`);
+  }
+  if ("lt" in filter) {
+    const placeholder = createPlaceholder(dialect, state, encodeValue(field, dialect, filter.lt));
+    clauses.push(`${column} < ${placeholder}`);
+  }
+  if ("lte" in filter) {
+    const placeholder = createPlaceholder(dialect, state, encodeValue(field, dialect, filter.lte));
+    clauses.push(`${column} <= ${placeholder}`);
+  }
+  if (!clauses.length) return "1 = 1";
+  if (clauses.length === 1) return clauses[0];
+  return `(${clauses.join(" and ")})`;
+}
+function compileWhere(model, where, dialect, state) {
+  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})`);
+      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})`);
+      if (nested.length) clauses.push(`(${nested.join(" or ")})`);
+      continue;
+    }
+    if (key === "NOT") {
+      const nested = compileWhere(model, value, dialect, state);
+      if (nested) clauses.push(`not (${nested})`);
+      continue;
+    }
+    clauses.push(compileFieldFilter(model, key, value, dialect, state));
+  }
+  if (!clauses.length) return void 0;
+  return clauses.join(" and ");
+}
+function compileOrderBy(model, orderBy, dialect) {
+  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"}`;
+  });
+  if (!parts.length) return "";
+  return ` order by ${parts.join(", ")}`;
+}
+function compilePagination(dialect, take, skip) {
+  if (take === void 0 && skip === void 0) return "";
+  if (take !== void 0 && skip !== void 0) {
+    return ` limit ${take} offset ${skip}`;
+  }
+  if (take !== void 0) {
+    return ` limit ${take}`;
+  }
+  if (dialect === "postgres") {
+    return ` offset ${skip ?? 0}`;
+  }
+  if (dialect === "mysql") {
+    return ` limit 18446744073709551615 offset ${skip ?? 0}`;
+  }
+  return ` limit -1 offset ${skip ?? 0}`;
+}
+function buildSelectStatement(model, dialect, args) {
+  const state = { params: [] };
+  const selectList = Object.values(model.fields).map(
+    (field) => `${quoteIdentifier(model.table, 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);
+  if (where) sql += ` where ${where}`;
+  sql += compileOrderBy(model, args.orderBy, dialect);
+  sql += compilePagination(dialect, args.take, args.skip);
+  return { sql, params: state.params };
+}
+function buildCountStatement(model, dialect, where) {
+  const state = { params: [] };
+  let sql = `select count(*) as ${quoteIdentifier("count", dialect)} from ${quoteIdentifier(model.table, dialect)}`;
+  const compiledWhere = compileWhere(model, where, dialect, state);
+  if (compiledWhere) sql += ` where ${compiledWhere}`;
+  return { sql, params: state.params };
+}
+function buildInsertRow(model, data) {
+  const row = {};
+  for (const field of Object.values(model.fields)) {
+    row[field.name] = applyDefault(data[field.name], field);
+  }
+  return row;
+}
+function buildIdentityWhere(model, row) {
+  const field = identityField(model);
+  const value = row[field.name];
+  if (value === void 0) {
+    throw new Error(
+      `Model "${model.name}" could not resolve the identity field "${field.name}" from the current row.`
+    );
+  }
+  return {
+    [field.name]: value
+  };
+}
+function buildInsertStatement(model, dialect, row) {
+  const state = { params: [] };
+  const fields = Object.values(model.fields).filter((field) => row[field.name] !== void 0);
+  const columns = fields.map((field) => quoteIdentifier(field.column, dialect));
+  const values = fields.map(
+    (field) => createPlaceholder(dialect, state, encodeValue(field, dialect, row[field.name]))
+  );
+  return {
+    sql: `insert into ${quoteIdentifier(model.table, dialect)} (${columns.join(", ")}) values (${values.join(", ")})`,
+    params: state.params
+  };
+}
+function buildUpsertStatement(model, dialect, row, updateData, conflictField) {
+  const state = { params: [] };
+  const insertFields = Object.values(model.fields).filter((field) => row[field.name] !== void 0);
+  const columns = insertFields.map((field) => quoteIdentifier(field.column, dialect));
+  const values = insertFields.map(
+    (field) => createPlaceholder(dialect, state, encodeValue(field, dialect, row[field.name]))
+  );
+  const updateEntries = Object.entries(updateData).filter(([, value]) => value !== void 0);
+  const conflictColumn = quoteIdentifier(conflictField.column, dialect);
+  let sql = `insert into ${quoteIdentifier(model.table, dialect)} (${columns.join(", ")}) values (${values.join(", ")})`;
+  if (dialect === "mysql") {
+    const updateClause2 = updateEntries.length ? updateEntries.map(([fieldName, value]) => {
+      const field = model.fields[fieldName];
+      if (!field) {
+        throw new Error(`Unknown field "${fieldName}" on model "${model.name}".`);
+      }
+      const placeholder = createPlaceholder(dialect, state, encodeValue(field, dialect, value));
+      return `${quoteIdentifier(field.column, dialect)} = ${placeholder}`;
+    }) : [`${conflictColumn} = ${conflictColumn}`];
+    sql += ` on duplicate key update ${updateClause2.join(", ")}`;
+    return {
+      sql,
+      params: state.params
+    };
+  }
+  if (!updateEntries.length) {
+    sql += ` on conflict (${conflictColumn}) do nothing`;
+    return {
+      sql,
+      params: state.params
+    };
+  }
+  const updateClause = updateEntries.map(([fieldName, value]) => {
+    const field = model.fields[fieldName];
+    if (!field) {
+      throw new Error(`Unknown field "${fieldName}" on model "${model.name}".`);
+    }
+    const placeholder = createPlaceholder(dialect, state, encodeValue(field, dialect, value));
+    return `${quoteIdentifier(field.column, dialect)} = ${placeholder}`;
+  });
+  sql += ` on conflict (${conflictColumn}) do update set ${updateClause.join(", ")}`;
+  return {
+    sql,
+    params: state.params
+  };
+}
+function buildUpdateStatement(model, dialect, data, where) {
+  const state = { params: [] };
+  const entries = Object.entries(data).filter(([, value]) => value !== void 0);
+  if (!entries.length) {
+    return null;
+  }
+  const setClause = entries.map(([fieldName, value]) => {
+    const field = model.fields[fieldName];
+    if (!field) {
+      throw new Error(`Unknown field "${fieldName}" on model "${model.name}".`);
+    }
+    const placeholder = createPlaceholder(dialect, state, encodeValue(field, dialect, value));
+    return `${quoteIdentifier(field.column, dialect)} = ${placeholder}`;
+  });
+  const compiledWhere = compileWhere(model, where, dialect, state);
+  if (!compiledWhere) {
+    throw new Error(`Update on model "${model.name}" requires a where clause.`);
+  }
+  return {
+    sql: `update ${quoteIdentifier(model.table, dialect)} set ${setClause.join(", ")} where ${compiledWhere}`,
+    params: state.params
+  };
+}
+function buildDeleteStatement(model, dialect, where) {
+  const state = { params: [] };
+  const compiledWhere = compileWhere(model, where, dialect, state);
+  if (!compiledWhere) {
+    throw new Error(`Delete on model "${model.name}" requires a where clause.`);
+  }
+  return {
+    sql: `delete from ${quoteIdentifier(model.table, dialect)} where ${compiledWhere}`,
+    params: state.params
+  };
+}
+function createSqliteAdapter(database) {
+  let transactionDepth = 0;
+  const adapter = {
+    dialect: "sqlite",
+    async query(sql, params) {
+      const statement = database.prepare(sql);
+      if (/^\s*(select|with)\b/i.test(sql)) {
+        const rows = statement.all(...params);
+        return {
+          rows,
+          affectedRows: rows.length
+        };
+      }
+      const result = statement.run(...params);
+      return {
+        rows: [],
+        affectedRows: Number(result?.changes ?? 0)
+      };
+    },
+    async transaction(run) {
+      const savepoint = `farming_labs_${transactionDepth + 1}`;
+      if (transactionDepth === 0) {
+        database.exec("begin");
+      } else {
+        database.exec(`savepoint ${savepoint}`);
+      }
+      transactionDepth += 1;
+      try {
+        const result = await run(adapter);
+        transactionDepth -= 1;
+        if (transactionDepth === 0) {
+          database.exec("commit");
+        } else {
+          database.exec(`release savepoint ${savepoint}`);
+        }
+        return result;
+      } catch (error) {
+        transactionDepth -= 1;
+        if (transactionDepth === 0) {
+          database.exec("rollback");
+        } else {
+          database.exec(`rollback to savepoint ${savepoint}`);
+          database.exec(`release savepoint ${savepoint}`);
+        }
+        throw error;
+      }
+    }
+  };
+  return adapter;
+}
+function createPgTransactionalAdapter(client) {
+  let transactionDepth = 0;
+  const adapter = {
+    dialect: "postgres",
+    async query(sql, params) {
+      const result = await client.query(sql, params);
+      return {
+        rows: result.rows ?? [],
+        affectedRows: Number(result.rowCount ?? result.rows?.length ?? 0)
+      };
+    },
+    async transaction(run) {
+      const savepoint = `farming_labs_${transactionDepth + 1}`;
+      if (transactionDepth === 0) {
+        await client.query("begin");
+      } else {
+        await client.query(`savepoint ${savepoint}`);
+      }
+      transactionDepth += 1;
+      try {
+        const result = await run(adapter);
+        transactionDepth -= 1;
+        if (transactionDepth === 0) {
+          await client.query("commit");
+        } else {
+          await client.query(`release savepoint ${savepoint}`);
+        }
+        return result;
+      } catch (error) {
+        transactionDepth -= 1;
+        if (transactionDepth === 0) {
+          await client.query("rollback");
+        } else {
+          await client.query(`rollback to savepoint ${savepoint}`);
+          await client.query(`release savepoint ${savepoint}`);
+        }
+        throw error;
+      }
+    }
+  };
+  return adapter;
+}
+function createPgPoolAdapter(pool) {
+  return {
+    dialect: "postgres",
+    async query(sql, params) {
+      const result = await pool.query(sql, params);
+      return {
+        rows: result.rows ?? [],
+        affectedRows: Number(result.rowCount ?? result.rows?.length ?? 0)
+      };
+    },
+    async transaction(run) {
+      const client = await pool.connect();
+      try {
+        return await createPgTransactionalAdapter(client).transaction(run);
+      } finally {
+        client.release?.();
+      }
+    }
+  };
+}
+function createMysqlTransactionalAdapter(connection) {
+  let transactionDepth = 0;
+  const adapter = {
+    dialect: "mysql",
+    async query(sql, params) {
+      const [result] = await connection.execute(sql, params);
+      if (Array.isArray(result)) {
+        return {
+          rows: result,
+          affectedRows: result.length
+        };
+      }
+      return {
+        rows: [],
+        affectedRows: Number(result.affectedRows ?? 0)
+      };
+    },
+    async transaction(run) {
+      const savepoint = `farming_labs_${transactionDepth + 1}`;
+      if (transactionDepth === 0) {
+        await connection.beginTransaction();
+      } else {
+        await connection.execute(`savepoint ${savepoint}`);
+      }
+      transactionDepth += 1;
+      try {
+        const result = await run(adapter);
+        transactionDepth -= 1;
+        if (transactionDepth === 0) {
+          await connection.commit();
+        } else {
+          await connection.execute(`release savepoint ${savepoint}`);
+        }
+        return result;
+      } catch (error) {
+        transactionDepth -= 1;
+        if (transactionDepth === 0) {
+          await connection.rollback();
+        } else {
+          await connection.execute(`rollback to savepoint ${savepoint}`);
+          await connection.execute(`release savepoint ${savepoint}`);
+        }
+        throw error;
+      }
+    }
+  };
+  return adapter;
+}
+function createMysqlPoolAdapter(pool) {
+  return {
+    dialect: "mysql",
+    async query(sql, params) {
+      const [result] = await pool.execute(sql, params);
+      if (Array.isArray(result)) {
+        return {
+          rows: result,
+          affectedRows: result.length
+        };
+      }
+      return {
+        rows: [],
+        affectedRows: Number(result.affectedRows ?? 0)
+      };
+    },
+    async transaction(run) {
+      const connection = await pool.getConnection();
+      try {
+        return await createMysqlTransactionalAdapter(connection).transaction(run);
+      } finally {
+        connection.release?.();
+      }
+    }
+  };
+}
+function createSqlDriver(adapter) {
+  async function loadRows(schema, modelName, args) {
+    const manifest = getManifest(schema);
+    const model = manifest.models[modelName];
+    const statement = buildSelectStatement(model, adapter.dialect, args);
+    const result = await adapter.query(statement.sql, statement.params);
+    const rows = result.rows.map((row) => decodeRow(model, row));
+    return Promise.all(rows.map((row) => projectRow(schema, modelName, row, args.select)));
+  }
+  async function loadOneRow(schema, modelName, args) {
+    const rows = await loadRows(schema, modelName, {
+      ...args,
+      take: 1
+    });
+    return rows[0] ?? null;
+  }
+  async function loadRawOneRow(schema, modelName, args) {
+    const manifest = getManifest(schema);
+    const model = manifest.models[modelName];
+    const statement = buildSelectStatement(model, adapter.dialect, {
+      ...args,
+      take: 1
+    });
+    const result = await adapter.query(statement.sql, statement.params);
+    const row = result.rows[0];
+    return row ? decodeRow(model, row) : null;
+  }
+  async function projectRow(schema, modelName, row, select) {
+    const manifest = getManifest(schema);
+    const model = manifest.models[modelName];
+    const output = {};
+    if (!select) {
+      for (const fieldName of Object.keys(model.fields)) {
+        output[fieldName] = row[fieldName];
+      }
+      return output;
+    }
+    for (const [key, value] of Object.entries(select)) {
+      if (value === void 0) continue;
+      if (key in model.fields && value === true) {
+        output[key] = row[key];
+        continue;
+      }
+      if (key in schema.models[modelName].relations) {
+        output[key] = await resolveRelation(
+          schema,
+          modelName,
+          key,
+          row,
+          value
+        );
+      }
+    }
+    return output;
+  }
+  async function resolveRelation(schema, modelName, relationName, row, value) {
+    const manifest = getManifest(schema);
+    const relation = schema.models[modelName].relations[relationName];
+    const relationArgs = value === true ? {} : value;
+    if (relation.kind === "belongsTo") {
+      const foreignField = manifest.models[modelName].fields[relation.foreignKey];
+      const targetReference = parseReference(foreignField?.references);
+      const targetField2 = targetReference?.field ?? identityField(manifest.models[relation.target]).name;
+      const foreignValue = row[relation.foreignKey];
+      if (foreignValue == null) return null;
+      return loadOneRow(schema, relation.target, {
+        where: mergeWhere(
+          relationArgs.where,
+          {
+            [targetField2]: foreignValue
+          }
+        ),
+        orderBy: relationArgs.orderBy,
+        select: relationArgs.select
+      });
+    }
+    if (relation.kind === "hasOne") {
+      const targetModel = manifest.models[relation.target];
+      const foreignField = targetModel.fields[relation.foreignKey];
+      const sourceReference = parseReference(foreignField?.references);
+      const sourceField2 = sourceReference?.field ?? identityField(manifest.models[modelName]).name;
+      const sourceValue2 = row[sourceField2];
+      if (sourceValue2 == null) return null;
+      return loadOneRow(schema, relation.target, {
+        where: mergeWhere(
+          relationArgs.where,
+          {
+            [relation.foreignKey]: sourceValue2
+          }
+        ),
+        orderBy: relationArgs.orderBy,
+        select: relationArgs.select
+      });
+    }
+    if (relation.kind === "hasMany") {
+      const targetModel = manifest.models[relation.target];
+      const foreignField = targetModel.fields[relation.foreignKey];
+      const sourceReference = parseReference(foreignField?.references);
+      const sourceField2 = sourceReference?.field ?? identityField(manifest.models[modelName]).name;
+      const sourceValue2 = row[sourceField2];
+      if (sourceValue2 == null) return [];
+      return loadRows(schema, relation.target, {
+        where: mergeWhere(
+          relationArgs.where,
+          {
+            [relation.foreignKey]: sourceValue2
+          }
+        ),
+        orderBy: relationArgs.orderBy,
+        take: relationArgs.take,
+        skip: relationArgs.skip,
+        select: relationArgs.select
+      });
+    }
+    const throughModel = manifest.models[relation.through];
+    const throughFromReference = parseReference(throughModel.fields[relation.from]?.references);
+    const throughToReference = parseReference(throughModel.fields[relation.to]?.references);
+    const sourceField = throughFromReference?.field ?? identityField(manifest.models[modelName]).name;
+    const targetField = throughToReference?.field ?? identityField(manifest.models[relation.target]).name;
+    const sourceValue = row[sourceField];
+    if (sourceValue == null) return [];
+    const throughRows = await loadRows(schema, relation.through, {
+      where: {
+        [relation.from]: sourceValue
+      }
+    });
+    const targetIds = throughRows.map((item) => item[relation.to]).filter((item) => item != null);
+    if (!targetIds.length) return [];
+    return loadRows(schema, relation.target, {
+      where: mergeWhere(
+        relationArgs.where,
+        {
+          [targetField]: {
+            in: targetIds
+          }
+        }
+      ),
+      orderBy: relationArgs.orderBy,
+      take: relationArgs.take,
+      skip: relationArgs.skip,
+      select: relationArgs.select
+    });
+  }
+  const driver = {
+    async findMany(schema, model, args) {
+      return loadRows(schema, model, args);
+    },
+    async findFirst(schema, model, args) {
+      return loadOneRow(schema, model, args);
+    },
+    async findUnique(schema, model, args) {
+      return loadOneRow(schema, model, args);
+    },
+    async count(schema, model, args) {
+      const manifest = getManifest(schema);
+      const statement = buildCountStatement(
+        manifest.models[model],
+        adapter.dialect,
+        args?.where
+      );
+      const result = await adapter.query(statement.sql, statement.params);
+      const rawCount = result.rows[0]?.count;
+      if (typeof rawCount === "number") return rawCount;
+      return Number.parseInt(String(rawCount ?? 0), 10);
+    },
+    async create(schema, model, args) {
+      const manifest = getManifest(schema);
+      identityField(manifest.models[model]);
+      const row = buildInsertRow(
+        manifest.models[model],
+        args.data
+      );
+      const statement = buildInsertStatement(manifest.models[model], adapter.dialect, row);
+      await adapter.query(statement.sql, statement.params);
+      return loadOneRow(schema, model, {
+        where: buildIdentityWhere(manifest.models[model], row),
+        select: args.select
+      });
+    },
+    async createMany(schema, model, args) {
+      const results = [];
+      for (const entry of args.data) {
+        results.push(
+          await driver.create(schema, model, {
+            data: entry,
+            select: args.select
+          })
+        );
+      }
+      return results;
+    },
+    async update(schema, model, args) {
+      const manifest = getManifest(schema);
+      const current = await loadRawOneRow(schema, model, {
+        where: args.where
+      });
+      if (!current) return null;
+      const update = buildUpdateStatement(
+        manifest.models[model],
+        adapter.dialect,
+        args.data,
+        buildIdentityWhere(manifest.models[model], current)
+      );
+      if (update) {
+        await adapter.query(update.sql, update.params);
+      }
+      return loadOneRow(schema, model, {
+        where: buildIdentityWhere(manifest.models[model], current),
+        select: args.select
+      });
+    },
+    async updateMany(schema, model, args) {
+      const manifest = getManifest(schema);
+      const update = buildUpdateStatement(
+        manifest.models[model],
+        adapter.dialect,
+        args.data,
+        args.where
+      );
+      if (!update) return 0;
+      const result = await adapter.query(update.sql, update.params);
+      return result.affectedRows;
+    },
+    async upsert(schema, model, args) {
+      const manifest = getManifest(schema);
+      const modelManifest = manifest.models[model];
+      const conflict = extractUpsertConflict(modelManifest, args.where);
+      validateUpsertUpdateData(
+        modelManifest,
+        args.update,
+        conflict
+      );
+      const row = buildInsertRow(
+        modelManifest,
+        mergeUpsertCreateData(
+          modelManifest,
+          args.create,
+          conflict
+        )
+      );
+      const statement = buildUpsertStatement(
+        modelManifest,
+        adapter.dialect,
+        row,
+        args.update,
+        conflict.field
+      );
+      await adapter.query(statement.sql, statement.params);
+      return loadOneRow(schema, model, {
+        where: args.where,
+        select: args.select
+      });
+    },
+    async delete(schema, model, args) {
+      const manifest = getManifest(schema);
+      const current = await loadRawOneRow(schema, model, {
+        where: args.where
+      });
+      if (!current) return 0;
+      const statement = buildDeleteStatement(
+        manifest.models[model],
+        adapter.dialect,
+        buildIdentityWhere(manifest.models[model], current)
+      );
+      const result = await adapter.query(statement.sql, statement.params);
+      return result.affectedRows;
+    },
+    async deleteMany(schema, model, args) {
+      const manifest = getManifest(schema);
+      const statement = buildDeleteStatement(
+        manifest.models[model],
+        adapter.dialect,
+        args.where
+      );
+      const result = await adapter.query(statement.sql, statement.params);
+      return result.affectedRows;
+    },
+    async transaction(_schema, run) {
+      return adapter.transaction(async (txAdapter) => run(createSqlDriver(txAdapter)));
+    }
+  };
+  return driver;
+}
+function createSqliteDriver(database) {
+  return createSqlDriver(createSqliteAdapter(database));
+}
+function createPgPoolDriver(pool) {
+  return createSqlDriver(createPgPoolAdapter(pool));
+}
+function createPgClientDriver(client) {
+  return createSqlDriver(createPgTransactionalAdapter(client));
+}
+function createMysqlDriver(poolOrConnection) {
+  const adapter = "getConnection" in poolOrConnection ? createMysqlPoolAdapter(poolOrConnection) : createMysqlTransactionalAdapter(poolOrConnection);
+  return createSqlDriver(adapter);
+}
+export {
+  createMysqlDriver,
+  createPgClientDriver,
+  createPgPoolDriver,
+  createSqliteDriver
+};
+//# sourceMappingURL=index.js.map