@farming-labs/orm-mongoose 0.0.1

package/dist/index.js

@@ -0,0 +1,634 @@
+// 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 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 Mongoose 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 isFilterObject(value) {
+  return !!value && typeof value === "object" && !(value instanceof Date) && !Array.isArray(value);
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+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 parseReference(reference) {
+  if (!reference) return null;
+  const [model, field] = reference.split(".");
+  if (!model || !field) return null;
+  return { model, field };
+}
+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 isExecLike(value) {
+  return !!value && typeof value === "object" && "exec" in value;
+}
+async function execute(operation, session) {
+  if (isExecLike(operation)) {
+    const query = session && typeof operation.session === "function" ? operation.session(session) : operation;
+    return query.exec();
+  }
+  return operation;
+}
+async function normalizeCreated(doc) {
+  const result = await doc;
+  return Array.isArray(result) ? result[0] ?? null : result;
+}
+function createMongooseDriverInternal(config, state = {}) {
+  function getModel(modelName) {
+    const model = config.models[modelName];
+    if (!model) {
+      throw new Error(`No Mongoose model was provided for schema model "${modelName}".`);
+    }
+    return model;
+  }
+  function fieldTransform(modelName, fieldName) {
+    return config.transforms?.[modelName]?.[fieldName];
+  }
+  function encodeValue(modelName, field, value) {
+    if (value === void 0) return value;
+    if (value === null) return null;
+    let next = value;
+    if (field.kind === "boolean") {
+      next = Boolean(next);
+    } else if (field.kind === "datetime") {
+      next = next instanceof Date ? next : new Date(String(next));
+    }
+    const transform = fieldTransform(modelName, field.name);
+    return transform?.encode ? transform.encode(next) : next;
+  }
+  function decodeValue(modelName, field, value) {
+    if (value === void 0) return value;
+    if (value === null) return null;
+    const transform = fieldTransform(modelName, field.name);
+    let next = transform?.decode ? transform.decode(value) : value;
+    if (field.kind === "boolean") {
+      return Boolean(next);
+    }
+    if (field.kind === "datetime") {
+      return next instanceof Date ? next : new Date(String(next));
+    }
+    if (field.kind === "id") {
+      return typeof next === "string" ? next : String(next);
+    }
+    return next;
+  }
+  function buildDocument(model, data) {
+    const doc = {};
+    for (const field of Object.values(model.fields)) {
+      const value = applyDefault(data[field.name], field);
+      if (value !== void 0) {
+        doc[field.column] = encodeValue(model.name, field, value);
+      }
+    }
+    return doc;
+  }
+  function buildUpdate(model, data) {
+    const update = {};
+    for (const [fieldName, value] of Object.entries(data)) {
+      if (value === void 0) continue;
+      const field = model.fields[fieldName];
+      if (!field) {
+        throw new Error(`Unknown field "${fieldName}" on model "${model.name}".`);
+      }
+      update[field.column] = encodeValue(model.name, field, value);
+    }
+    return update;
+  }
+  function decodeRow(model, doc) {
+    const output = {};
+    for (const field of Object.values(model.fields)) {
+      output[field.name] = decodeValue(model.name, field, doc[field.column]);
+    }
+    return output;
+  }
+  function compileFieldFilter(model, fieldName, filter) {
+    const field = model.fields[fieldName];
+    if (!field) {
+      throw new Error(`Unknown field "${fieldName}" on model "${model.name}".`);
+    }
+    if (!isFilterObject(filter)) {
+      return {
+        [field.column]: encodeValue(model.name, field, filter)
+      };
+    }
+    const operations = {};
+    if ("eq" in filter) {
+      operations.$eq = encodeValue(model.name, field, filter.eq);
+    }
+    if ("not" in filter) {
+      operations.$ne = encodeValue(model.name, field, filter.not);
+    }
+    if ("in" in filter) {
+      const values = Array.isArray(filter.in) ? filter.in : [];
+      operations.$in = values.map((value) => encodeValue(model.name, field, value));
+    }
+    if ("contains" in filter) {
+      operations.$regex = new RegExp(escapeRegex(String(filter.contains ?? "")));
+    }
+    if ("gt" in filter) {
+      operations.$gt = encodeValue(model.name, field, filter.gt);
+    }
+    if ("gte" in filter) {
+      operations.$gte = encodeValue(model.name, field, filter.gte);
+    }
+    if ("lt" in filter) {
+      operations.$lt = encodeValue(model.name, field, filter.lt);
+    }
+    if ("lte" in filter) {
+      operations.$lte = encodeValue(model.name, field, filter.lte);
+    }
+    return {
+      [field.column]: operations
+    };
+  }
+  function compileWhere(model, where) {
+    if (!where) return {};
+    const clauses = [];
+    for (const [key, value] of Object.entries(where)) {
+      if (key === "AND") {
+        const nested = (Array.isArray(value) ? value : []).map((item) => compileWhere(model, item)).filter((item) => Object.keys(item).length > 0);
+        if (nested.length) clauses.push({ $and: nested });
+        continue;
+      }
+      if (key === "OR") {
+        const nested = (Array.isArray(value) ? value : []).map((item) => compileWhere(model, item)).filter((item) => Object.keys(item).length > 0);
+        if (nested.length) clauses.push({ $or: nested });
+        continue;
+      }
+      if (key === "NOT") {
+        const nested = compileWhere(model, value);
+        if (Object.keys(nested).length) clauses.push({ $nor: [nested] });
+        continue;
+      }
+      clauses.push(compileFieldFilter(model, key, value));
+    }
+    if (!clauses.length) return {};
+    if (clauses.length === 1) return clauses[0];
+    return {
+      $and: clauses
+    };
+  }
+  function compileOrderBy(model, orderBy) {
+    if (!orderBy) return void 0;
+    const output = {};
+    for (const [fieldName, direction] of Object.entries(orderBy)) {
+      const field = model.fields[fieldName];
+      if (!field) continue;
+      output[field.column] = direction === "desc" ? -1 : 1;
+    }
+    return Object.keys(output).length ? output : void 0;
+  }
+  async function runFindMany(model, args) {
+    const query = getModel(model.name).find(compileWhere(model, args.where));
+    const orderBy = compileOrderBy(model, args.orderBy);
+    if (orderBy) query.sort(orderBy);
+    if (args.skip !== void 0) query.skip(args.skip);
+    if (args.take !== void 0) query.limit(args.take);
+    if (state.session) query.session(state.session);
+    query.lean();
+    return query.exec();
+  }
+  async function runFindOne(model, args) {
+    const orderBy = compileOrderBy(model, args.orderBy);
+    if (orderBy) {
+      const rows = await runFindMany(model, {
+        ...args,
+        take: 1
+      });
+      return rows[0] ?? null;
+    }
+    const query = getModel(model.name).findOne(compileWhere(model, args.where));
+    if (state.session) query.session(state.session);
+    query.lean();
+    return query.exec();
+  }
+  async function loadRows(schema, modelName, args) {
+    const manifest = getManifest(schema);
+    const model = manifest.models[modelName];
+    const docs = await runFindMany(model, args);
+    const rows = docs.map((doc) => decodeRow(model, doc));
+    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 doc = await runFindOne(model, args);
+    return doc ? decodeRow(model, doc) : 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
+    });
+  }
+  async function runTransaction(run) {
+    if (state.session) {
+      return run(createMongooseDriverInternal(config, state));
+    }
+    const startSession = config.startSession ?? config.connection?.startSession.bind(config.connection);
+    if (!startSession) {
+      return run(createMongooseDriverInternal(config, state));
+    }
+    const session = await startSession();
+    try {
+      if (session.withTransaction) {
+        return await session.withTransaction(
+          () => run(
+            createMongooseDriverInternal(config, {
+              session
+            })
+          )
+        );
+      }
+      if (session.startTransaction && session.commitTransaction && session.abortTransaction) {
+        session.startTransaction();
+        try {
+          const result = await run(
+            createMongooseDriverInternal(config, {
+              session
+            })
+          );
+          await session.commitTransaction();
+          return result;
+        } catch (error) {
+          await session.abortTransaction();
+          throw error;
+        }
+      }
+      return run(
+        createMongooseDriverInternal(config, {
+          session
+        })
+      );
+    } finally {
+      await session.endSession?.();
+    }
+  }
+  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 result = await execute(
+        getModel(model).countDocuments(
+          compileWhere(manifest.models[model], args?.where)
+        ),
+        state.session
+      );
+      return Number(result);
+    },
+    async create(schema, model, args) {
+      const manifest = getManifest(schema);
+      const created = await normalizeCreated(
+        getModel(model).create(
+          buildDocument(manifest.models[model], args.data),
+          state.session ? { session: state.session } : void 0
+        )
+      );
+      if (!created) {
+        throw new Error(`Create on model "${String(model)}" did not return a document.`);
+      }
+      const row = decodeRow(manifest.models[model], created);
+      return projectRow(schema, model, row, 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 updated = await getModel(model).findOneAndUpdate(
+        compileWhere(manifest.models[model], args.where),
+        {
+          $set: buildUpdate(manifest.models[model], args.data)
+        },
+        {
+          new: true,
+          returnDocument: "after",
+          session: state.session
+        }
+      ).lean().exec();
+      if (!updated) return null;
+      return projectRow(
+        schema,
+        model,
+        decodeRow(manifest.models[model], updated),
+        args.select
+      );
+    },
+    async updateMany(schema, model, args) {
+      const manifest = getManifest(schema);
+      const update = buildUpdate(manifest.models[model], args.data);
+      if (!Object.keys(update).length) return 0;
+      const result = await execute(
+        getModel(model).updateMany(
+          compileWhere(manifest.models[model], args.where),
+          {
+            $set: update
+          },
+          state.session ? { session: state.session } : void 0
+        ),
+        state.session
+      );
+      return Number(result.modifiedCount ?? result.matchedCount ?? 0);
+    },
+    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 created = buildDocument(
+        modelManifest,
+        mergeUpsertCreateData(
+          modelManifest,
+          args.create,
+          conflict
+        )
+      );
+      const updated = await getModel(model).findOneAndUpdate(
+        compileWhere(modelManifest, args.where),
+        {
+          $set: buildUpdate(modelManifest, args.update),
+          $setOnInsert: created
+        },
+        {
+          upsert: true,
+          new: true,
+          returnDocument: "after",
+          session: state.session
+        }
+      ).lean().exec();
+      if (!updated) {
+        throw new Error(`Upsert on model "${String(model)}" did not return a document.`);
+      }
+      return projectRow(
+        schema,
+        model,
+        decodeRow(modelManifest, updated),
+        args.select
+      );
+    },
+    async delete(schema, model, args) {
+      const manifest = getManifest(schema);
+      const deleted = await getModel(model).findOneAndDelete(
+        compileWhere(manifest.models[model], args.where),
+        state.session ? { session: state.session } : void 0
+      ).lean().exec();
+      return deleted ? 1 : 0;
+    },
+    async deleteMany(schema, model, args) {
+      const manifest = getManifest(schema);
+      const result = await execute(
+        getModel(model).deleteMany(
+          compileWhere(manifest.models[model], args.where),
+          state.session ? { session: state.session } : void 0
+        ),
+        state.session
+      );
+      return Number(result.deletedCount ?? 0);
+    },
+    async transaction(_schema, run) {
+      return runTransaction(run);
+    }
+  };
+  return driver;
+}
+function createMongooseDriver(config) {
+  return createMongooseDriverInternal(config);
+}
+export {
+  createMongooseDriver
+};
+//# sourceMappingURL=index.js.map