@farming-labs/orm 0.0.9 → 0.0.10

package/dist/index.cjs

@@ -32,12 +32,17 @@ __export(index_exports, {
   hasOne: () => hasOne,
   id: () => id,
   manyToMany: () => manyToMany,
+  mergeUniqueLookupCreateData: () => mergeUniqueLookupCreateData,
   model: () => model,
   renderDrizzleSchema: () => renderDrizzleSchema,
   renderPrismaSchema: () => renderPrismaSchema,
   renderSafeSql: () => renderSafeSql,
   replaceGeneratedBlock: () => replaceGeneratedBlock,
-  string: () => string
+  requireUniqueLookup: () => requireUniqueLookup,
+  resolveRowIdentityLookup: () => resolveRowIdentityLookup,
+  string: () => string,
+  toUniqueLookupWhere: () => toUniqueLookupWhere,
+  validateUniqueLookupUpdateData: () => validateUniqueLookupUpdateData
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -187,6 +192,167 @@ function datetime() {
 }
 
 // src/manifest.ts
+function equalLookupValues(left, right) {
+  if (left instanceof Date && right instanceof Date) {
+    return left.getTime() === right.getTime();
+  }
+  return Object.is(left, right);
+}
+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 requireEqualityValues(model2, where, operation) {
+  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 === 0) {
+    throw new Error(
+      `${operation} on model "${model2.name}" requires a unique equality filter in "where".`
+    );
+  }
+  const values = {};
+  for (const fieldName of keys) {
+    const field = model2.fields[fieldName];
+    if (!field) {
+      throw new Error(`Unknown field "${fieldName}" on model "${model2.name}".`);
+    }
+    const { supported, value } = extractEqualityValue(where[fieldName]);
+    if (!supported || value === void 0 || value === null) {
+      throw new Error(
+        `${operation} on model "${model2.name}" requires the "where" field "${fieldName}" to use a single non-null equality value.`
+      );
+    }
+    values[fieldName] = value;
+  }
+  return values;
+}
+function sameFieldSet(left, right) {
+  return left.length === right.length && left.every((fieldName) => right.includes(fieldName));
+}
+function requireUniqueLookup(model2, where, operation) {
+  const values = requireEqualityValues(model2, where, operation);
+  const keys = Object.keys(values);
+  if (keys.length === 1) {
+    const field = model2.fields[keys[0]];
+    if (field.kind === "id") {
+      return {
+        kind: "id",
+        fields: [field],
+        values
+      };
+    }
+    if (field.unique) {
+      return {
+        kind: "field",
+        fields: [field],
+        values
+      };
+    }
+  }
+  const constraint = model2.constraints.unique.find(
+    (candidate) => sameFieldSet([...candidate.fields], keys)
+  );
+  if (!constraint) {
+    throw new Error(
+      `${operation} on model "${model2.name}" requires the "where" clause to match an id field, unique field, or declared unique constraint using equality values only.`
+    );
+  }
+  return {
+    kind: "constraint",
+    fields: constraint.fields.map((fieldName) => model2.fields[fieldName]),
+    values: Object.fromEntries(
+      constraint.fields.map((fieldName) => [fieldName, values[fieldName]])
+    ),
+    constraint
+  };
+}
+function resolveRowIdentityLookup(model2, row) {
+  const idField = model2.fields.id;
+  if (idField && row[idField.name] !== void 0 && row[idField.name] !== null) {
+    return {
+      kind: "id",
+      fields: [idField],
+      values: {
+        [idField.name]: row[idField.name]
+      }
+    };
+  }
+  const uniqueField = Object.values(model2.fields).find(
+    (field) => field.unique && row[field.name] !== void 0 && row[field.name] !== null
+  );
+  if (uniqueField) {
+    return {
+      kind: "field",
+      fields: [uniqueField],
+      values: {
+        [uniqueField.name]: row[uniqueField.name]
+      }
+    };
+  }
+  for (const constraint of model2.constraints.unique) {
+    if (constraint.fields.every(
+      (fieldName) => row[fieldName] !== void 0 && row[fieldName] !== null
+    )) {
+      return {
+        kind: "constraint",
+        fields: constraint.fields.map((fieldName) => model2.fields[fieldName]),
+        values: Object.fromEntries(
+          constraint.fields.map((fieldName) => [fieldName, row[fieldName]])
+        ),
+        constraint
+      };
+    }
+  }
+  throw new Error(
+    `Model "${model2.name}" requires an "id" field, unique field, or declared unique constraint with non-null values for identity lookups.`
+  );
+}
+function toUniqueLookupWhere(lookup) {
+  return Object.fromEntries(lookup.fields.map((field) => [field.name, lookup.values[field.name]]));
+}
+function mergeUniqueLookupCreateData(model2, createData, lookup, operation) {
+  const output = {
+    ...createData
+  };
+  for (const field of lookup.fields) {
+    const currentValue = output[field.name];
+    const expectedValue = lookup.values[field.name];
+    if (currentValue !== void 0 && !equalLookupValues(currentValue, expectedValue)) {
+      throw new Error(
+        `${operation} on model "${model2.name}" requires create.${field.name} to match where.${field.name}.`
+      );
+    }
+    output[field.name] = currentValue ?? expectedValue;
+  }
+  return output;
+}
+function validateUniqueLookupUpdateData(model2, updateData, lookup, operation) {
+  for (const field of lookup.fields) {
+    const nextValue = updateData[field.name];
+    if (nextValue !== void 0 && !equalLookupValues(nextValue, lookup.values[field.name])) {
+      throw new Error(
+        `${operation} on model "${model2.name}" cannot change the conflict field "${field.name}".`
+      );
+    }
+  }
+}
 function createConstraintName(table, columns, suffix) {
   const base = [table, ...columns].join("_").replace(/[^a-zA-Z0-9_]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "").toLowerCase();
   return `${base}_${suffix}`;
@@ -650,6 +816,14 @@ ${block}
 // src/memory.ts
 var import_node_crypto = require("crypto");
 var isDate = (value) => value instanceof Date;
+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 evaluateFilter(value, filter) {
   if (filter === void 0 || filter === null || typeof filter !== "object" || isDate(filter) || Array.isArray(filter)) {
     return value === filter;
@@ -842,6 +1016,11 @@ function createMemoryDriver(seed) {
       return projectRow(schema, model2, row, args.select);
     },
     async findUnique(schema, model2, args) {
+      requireUniqueLookup(
+        getManifest(schema).models[model2],
+        args.where,
+        "FindUnique"
+      );
       const row = applyQuery(getRows(model2), args)[0];
       if (!row) return null;
       return projectRow(schema, model2, row, args.select);
@@ -873,12 +1052,32 @@ function createMemoryDriver(seed) {
       return rows.length;
     },
     async upsert(schema, model2, args) {
+      const lookup = requireUniqueLookup(
+        getManifest(schema).models[model2],
+        args.where,
+        "Upsert"
+      );
+      validateUniqueLookupUpdateData(
+        getManifest(schema).models[model2],
+        args.update,
+        lookup,
+        "Upsert"
+      );
       const row = getRows(model2).find((item) => matchesWhere(item, args.where));
       if (row) {
         Object.assign(row, args.update);
         return projectRow(schema, model2, row, args.select);
       }
-      const created = buildRow(schema, model2, args.create);
+      const created = buildRow(
+        schema,
+        model2,
+        mergeUniqueLookupCreateData(
+          getManifest(schema).models[model2],
+          args.create,
+          lookup,
+          "Upsert"
+        )
+      );
       getRows(model2).push(created);
       return projectRow(schema, model2, created, args.select);
     },
@@ -974,11 +1173,16 @@ function defineSchema(models) {
   hasOne,
   id,
   manyToMany,
+  mergeUniqueLookupCreateData,
   model,
   renderDrizzleSchema,
   renderPrismaSchema,
   renderSafeSql,
   replaceGeneratedBlock,
-  string
+  requireUniqueLookup,
+  resolveRowIdentityLookup,
+  string,
+  toUniqueLookupWhere,
+  validateUniqueLookupUpdateData
 });
 //# sourceMappingURL=index.cjs.map