@farming-labs/orm 0.0.9 → 0.0.11

package/dist/index.cjs

@@ -28,16 +28,25 @@ __export(index_exports, {
   createOrm: () => createOrm,
   datetime: () => datetime,
   defineSchema: () => defineSchema,
+  equalValues: () => equalValues,
   hasMany: () => hasMany,
   hasOne: () => hasOne,
   id: () => id,
+  integer: () => integer,
+  isOperatorFilterObject: () => isOperatorFilterObject,
+  json: () => json,
   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);
 
@@ -113,6 +122,9 @@ var FieldBuilder = class {
     this.config = config;
   }
   _tag = "field";
+  __kind;
+  __nullable;
+  __value;
   unique() {
     return cloneField({
       ...this.config,
@@ -185,8 +197,189 @@ function datetime() {
     unique: false
   });
 }
+function integer() {
+  return new FieldBuilder({
+    kind: "integer",
+    nullable: false,
+    unique: false
+  });
+}
+function json() {
+  return new FieldBuilder({
+    kind: "json",
+    nullable: false,
+    unique: false
+  });
+}
 
 // src/manifest.ts
+var import_node_util = require("util");
+var filterOperatorKeys = /* @__PURE__ */ new Set(["eq", "contains", "in", "not", "gt", "gte", "lt", "lte"]);
+function isFilterObject(value) {
+  return !!value && typeof value === "object" && !(value instanceof Date) && !Array.isArray(value);
+}
+function isOperatorFilterObject(value) {
+  if (!isFilterObject(value)) {
+    return false;
+  }
+  const keys = Object.keys(value);
+  return keys.length > 0 && keys.every((key) => filterOperatorKeys.has(key));
+}
+function equalValues(left, right) {
+  return (0, import_node_util.isDeepStrictEqual)(left, right);
+}
+function extractEqualityValue(filter) {
+  if (!isOperatorFilterObject(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 && !equalValues(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 && !equalValues(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}`;
@@ -297,6 +490,10 @@ function prismaType(field) {
       return "Boolean";
     case "datetime":
       return "DateTime";
+    case "integer":
+      return "Int";
+    case "json":
+      return "Json";
   }
 }
 function drizzleConstraintProperty(constraint) {
@@ -317,6 +514,12 @@ function drizzleImports(dialect, manifest) {
   const needsDate = models.some(
     (model2) => Object.values(model2.fields).some((field) => field.kind === "datetime")
   );
+  const needsInteger = models.some(
+    (model2) => Object.values(model2.fields).some((field) => field.kind === "integer")
+  );
+  const needsJson = models.some(
+    (model2) => Object.values(model2.fields).some((field) => field.kind === "json")
+  );
   const needsIndexes = models.some(
     (model2) => model2.constraints.indexes.length || model2.constraints.unique.length
   );
@@ -325,7 +528,9 @@ function drizzleImports(dialect, manifest) {
       "pgTable",
       "text",
       needsBoolean ? "boolean" : null,
+      needsInteger ? "integer" : null,
       needsDate ? "timestamp" : null,
+      needsJson ? "jsonb" : null,
       needsIndexes ? "index" : null,
       needsIndexes ? "uniqueIndex" : null
     ].filter(Boolean);
@@ -336,7 +541,9 @@ function drizzleImports(dialect, manifest) {
       "varchar",
       "text",
       needsBoolean ? "boolean" : null,
+      needsInteger ? "int" : null,
       needsDate ? "datetime" : null,
+      needsJson ? "json" : null,
       needsIndexes ? "index" : null,
       needsIndexes ? "uniqueIndex" : null
     ].filter(Boolean);
@@ -350,6 +557,10 @@ function drizzleImports(dialect, manifest) {
   ].filter(Boolean);
 }
 function drizzleColumn(field, dialect, options = {}) {
+  const renderDefault = () => {
+    if (field.defaultValue === void 0 || field.kind === "json") return "";
+    return `.default(${JSON.stringify(field.defaultValue)})`;
+  };
   if (field.kind === "id") {
     if (dialect === "mysql") {
       return `varchar("${field.column}", { length: 191 }).primaryKey()`;
@@ -359,15 +570,30 @@ function drizzleColumn(field, dialect, options = {}) {
   if (field.kind === "string") {
     if (dialect === "mysql") {
       const base = field.unique || field.references || options.indexed ? `varchar("${field.column}", { length: 191 })` : `text("${field.column}")`;
-      return `${base}${field.nullable ? "" : ".notNull()"}${field.unique ? ".unique()" : ""}${field.defaultValue !== void 0 ? `.default(${JSON.stringify(field.defaultValue)})` : ""}`;
+      return `${base}${field.nullable ? "" : ".notNull()"}${field.unique ? ".unique()" : ""}${renderDefault()}`;
     }
-    return `text("${field.column}")${field.nullable ? "" : ".notNull()"}${field.unique ? ".unique()" : ""}${field.defaultValue !== void 0 ? `.default(${JSON.stringify(field.defaultValue)})` : ""}`;
+    return `text("${field.column}")${field.nullable ? "" : ".notNull()"}${field.unique ? ".unique()" : ""}${renderDefault()}`;
   }
   if (field.kind === "boolean") {
     if (dialect === "sqlite") {
-      return `integer("${field.column}", { mode: "boolean" })${field.nullable ? "" : ".notNull()"}${field.defaultValue !== void 0 ? `.default(${String(field.defaultValue)})` : ""}`;
+      return `integer("${field.column}", { mode: "boolean" })${field.nullable ? "" : ".notNull()"}${renderDefault()}`;
     }
-    return `boolean("${field.column}")${field.nullable ? "" : ".notNull()"}${field.defaultValue !== void 0 ? `.default(${String(field.defaultValue)})` : ""}`;
+    return `boolean("${field.column}")${field.nullable ? "" : ".notNull()"}${renderDefault()}`;
+  }
+  if (field.kind === "integer") {
+    if (dialect === "mysql") {
+      return `int("${field.column}")${field.nullable ? "" : ".notNull()"}${renderDefault()}`;
+    }
+    return `integer("${field.column}")${field.nullable ? "" : ".notNull()"}${renderDefault()}`;
+  }
+  if (field.kind === "json") {
+    if (dialect === "pg") {
+      return `jsonb("${field.column}")${field.nullable ? "" : ".notNull()"}`;
+    }
+    if (dialect === "mysql") {
+      return `json("${field.column}")${field.nullable ? "" : ".notNull()"}`;
+    }
+    return `text("${field.column}", { mode: "json" })${field.nullable ? "" : ".notNull()"}`;
   }
   if (dialect === "mysql") {
     return `datetime("${field.column}", { mode: "date" })${field.nullable ? "" : ".notNull()"}`;
@@ -387,6 +613,14 @@ function sqlType(field, dialect, options = {}) {
   if (field.kind === "boolean") {
     return dialect === "sqlite" ? "integer" : "boolean";
   }
+  if (field.kind === "integer") {
+    return "integer";
+  }
+  if (field.kind === "json") {
+    if (dialect === "postgres") return "jsonb";
+    if (dialect === "mysql") return "json";
+    return "text";
+  }
   if (dialect === "mysql") {
     return "datetime";
   }
@@ -440,7 +674,7 @@ function renderPrismaSchema(schema, options = {}) {
       if (field.kind === "id") modifiers.push("@id");
       if (field.generated === "id") modifiers.push("@default(cuid())");
       if (field.generated === "now") modifiers.push("@default(now())");
-      if (field.defaultValue !== void 0 && field.generated === void 0) {
+      if (field.defaultValue !== void 0 && field.generated === void 0 && field.kind !== "json") {
         modifiers.push(
           typeof field.defaultValue === "string" ? `@default("${field.defaultValue}")` : `@default(${String(field.defaultValue)})`
         );
@@ -598,7 +832,7 @@ function renderSafeSql(schema, options) {
       if (field.kind === "id") parts.push("primary key");
       if (!field.nullable) parts.push("not null");
       if (field.unique && field.kind !== "id") parts.push("unique");
-      if (field.defaultValue !== void 0) {
+      if (field.defaultValue !== void 0 && field.kind !== "json") {
         parts.push(
           `default ${typeof field.defaultValue === "string" ? `'${field.defaultValue}'` : String(field.defaultValue)}`
         );
@@ -649,17 +883,24 @@ ${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;
+  if (!isOperatorFilterObject(filter)) {
+    return equalValues(value, filter);
   }
   const record = filter;
-  if ("eq" in record && value !== record.eq) return false;
-  if ("not" in record && value === record.not) return false;
+  if ("eq" in record && !equalValues(value, record.eq)) return false;
+  if ("not" in record && equalValues(value, record.not)) return false;
   if ("in" in record) {
     const values = Array.isArray(record.in) ? record.in : [];
-    if (!values.includes(value)) return false;
+    if (!values.some((candidate) => equalValues(candidate, value))) return false;
   }
   if ("contains" in record) {
     if (typeof value !== "string" || typeof record.contains !== "string") return false;
@@ -842,6 +1083,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 +1119,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);
     },
@@ -970,15 +1236,24 @@ function defineSchema(models) {
   createOrm,
   datetime,
   defineSchema,
+  equalValues,
   hasMany,
   hasOne,
   id,
+  integer,
+  isOperatorFilterObject,
+  json,
   manyToMany,
+  mergeUniqueLookupCreateData,
   model,
   renderDrizzleSchema,
   renderPrismaSchema,
   renderSafeSql,
   replaceGeneratedBlock,
-  string
+  requireUniqueLookup,
+  resolveRowIdentityLookup,
+  string,
+  toUniqueLookupWhere,
+  validateUniqueLookupUpdateData
 });
 //# sourceMappingURL=index.cjs.map