@farming-labs/orm 0.0.8 → 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,199 @@ 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}`;
+}
+function normalizeConstraints(modelName, table, fields, constraints) {
+  const normalize = (entries, unique) => (entries ?? []).map((entry) => {
+    if (!entry.length) {
+      throw new Error(
+        `Model "${modelName}" defines an empty ${unique ? "unique" : "index"} constraint.`
+      );
+    }
+    const columns = entry.map((fieldName) => {
+      const field = fields[fieldName];
+      if (!field) {
+        throw new Error(
+          `Model "${modelName}" defines a ${unique ? "unique" : "index"} constraint on unknown field "${fieldName}".`
+        );
+      }
+      return field.column;
+    });
+    return {
+      name: createConstraintName(table, columns, unique ? "unique" : "idx"),
+      fields: [...entry],
+      columns,
+      unique
+    };
+  });
+  return {
+    unique: normalize(constraints.unique, true),
+    indexes: normalize(constraints.indexes, false)
+  };
+}
 function createManifest(schema) {
   const models = Object.fromEntries(
     Object.entries(schema.models).map(
@@ -214,7 +412,13 @@ function createManifest(schema) {
             table: definition.table,
             description: definition.description,
             fields,
-            relations: definition.relations
+            relations: definition.relations,
+            constraints: normalizeConstraints(
+              name,
+              definition.table,
+              fields,
+              definition.constraints
+            )
           }
         ];
       }
@@ -226,6 +430,7 @@ function createManifest(schema) {
 // src/generators.ts
 var capitalize = (value) => value.charAt(0).toUpperCase() + value.slice(1);
 var pluralize = (value) => value.endsWith("s") ? value : `${value}s`;
+var camelize = (value) => value.replace(/[^a-zA-Z0-9]+(.)/g, (_, char) => char.toUpperCase()).replace(/^[^a-zA-Z]+/, "").replace(/^[A-Z]/, (char) => char.toLowerCase());
 function resolveReferenceTarget(manifest, model2, foreignKey, fallbackTarget) {
   const reference = model2.fields[foreignKey]?.references;
   if (!reference) {
@@ -260,6 +465,16 @@ function prismaType(field) {
       return "DateTime";
   }
 }
+function drizzleConstraintProperty(constraint) {
+  return camelize(constraint.name) || "constraint";
+}
+function constrainedFields(model2) {
+  return new Set(
+    [...model2.constraints.unique, ...model2.constraints.indexes].flatMap(
+      (constraint) => constraint.fields
+    )
+  );
+}
 function drizzleImports(dialect, manifest) {
   const models = Object.values(manifest.models);
   const needsBoolean = models.some(
@@ -268,12 +483,17 @@ function drizzleImports(dialect, manifest) {
   const needsDate = models.some(
     (model2) => Object.values(model2.fields).some((field) => field.kind === "datetime")
   );
+  const needsIndexes = models.some(
+    (model2) => model2.constraints.indexes.length || model2.constraints.unique.length
+  );
   if (dialect === "pg") {
     return [
       "pgTable",
       "text",
       needsBoolean ? "boolean" : null,
-      needsDate ? "timestamp" : null
+      needsDate ? "timestamp" : null,
+      needsIndexes ? "index" : null,
+      needsIndexes ? "uniqueIndex" : null
     ].filter(Boolean);
   }
   if (dialect === "mysql") {
@@ -282,12 +502,20 @@ function drizzleImports(dialect, manifest) {
       "varchar",
       "text",
       needsBoolean ? "boolean" : null,
-      needsDate ? "datetime" : null
+      needsDate ? "datetime" : null,
+      needsIndexes ? "index" : null,
+      needsIndexes ? "uniqueIndex" : null
     ].filter(Boolean);
   }
-  return ["sqliteTable", "text", "integer"];
+  return [
+    "sqliteTable",
+    "text",
+    "integer",
+    needsIndexes ? "index" : null,
+    needsIndexes ? "uniqueIndex" : null
+  ].filter(Boolean);
 }
-function drizzleColumn(field, dialect) {
+function drizzleColumn(field, dialect, options = {}) {
   if (field.kind === "id") {
     if (dialect === "mysql") {
       return `varchar("${field.column}", { length: 191 }).primaryKey()`;
@@ -296,7 +524,7 @@ function drizzleColumn(field, dialect) {
   }
   if (field.kind === "string") {
     if (dialect === "mysql") {
-      const base = field.unique || field.references ? `varchar("${field.column}", { length: 191 })` : `text("${field.column}")`;
+      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 `text("${field.column}")${field.nullable ? "" : ".notNull()"}${field.unique ? ".unique()" : ""}${field.defaultValue !== void 0 ? `.default(${JSON.stringify(field.defaultValue)})` : ""}`;
@@ -313,14 +541,14 @@ function drizzleColumn(field, dialect) {
   if (dialect === "sqlite") {
     return `integer("${field.column}", { mode: "timestamp" })${field.nullable ? "" : ".notNull()"}`;
   }
-  return `timestamp("${field.column}")${field.nullable ? "" : ".notNull()"}`;
+  return `timestamp("${field.column}", { withTimezone: true, mode: "date" })${field.nullable ? "" : ".notNull()"}`;
 }
-function sqlType(field, dialect) {
+function sqlType(field, dialect, options = {}) {
   if (field.kind === "id") {
     return dialect === "mysql" ? "varchar(191)" : "text";
   }
   if (field.kind === "string") {
-    return dialect === "mysql" && (field.unique || field.references) ? "varchar(191)" : "text";
+    return dialect === "mysql" && (field.unique || field.references || options.indexed) ? "varchar(191)" : "text";
   }
   if (field.kind === "boolean") {
     return dialect === "sqlite" ? "integer" : "boolean";
@@ -331,7 +559,7 @@ function sqlType(field, dialect) {
   if (dialect === "sqlite") {
     return "text";
   }
-  return "timestamp";
+  return "timestamptz";
 }
 function sqlIdentifier(dialect, value) {
   if (dialect === "mysql") {
@@ -339,6 +567,14 @@ function sqlIdentifier(dialect, value) {
   }
   return `"${value}"`;
 }
+function sqlCreateIndexStatement(dialect, table, constraint) {
+  const indexName = sqlIdentifier(dialect, constraint.name);
+  const tableName = sqlIdentifier(dialect, table);
+  const columns = constraint.columns.map((column) => sqlIdentifier(dialect, column)).join(", ");
+  const createKeyword = constraint.unique ? "create unique index" : "create index";
+  const ifNotExists = dialect === "mysql" ? "" : " if not exists";
+  return `${createKeyword}${ifNotExists} ${indexName} on ${tableName}(${columns});`;
+}
 function renderPrismaSchema(schema, options = {}) {
   const manifest = createManifest(schema);
   const provider = options.provider ?? "postgresql";
@@ -421,10 +657,18 @@ function renderPrismaSchema(schema, options = {}) {
         relation.many ? `  ${relationName} ${capitalize(relation.sourceModel)}[]` : `  ${relationName} ${capitalize(relation.sourceModel)}?`
       );
     }
-    const mapLine = model2.table !== modelName ? `
-  @@map("${model2.table}")` : "";
+    const modelLines = [
+      ...lines,
+      ...model2.constraints.unique.map(
+        (constraint) => `  @@unique([${constraint.fields.join(", ")}])`
+      ),
+      ...model2.constraints.indexes.map(
+        (constraint) => `  @@index([${constraint.fields.join(", ")}])`
+      ),
+      ...model2.table !== modelName ? [`  @@map("${model2.table}")`] : []
+    ];
     return `model ${modelName} {
-${lines.join("\n")}${mapLine}
+${modelLines.join("\n")}
 }`;
   });
   return `generator ${generatorName} {
@@ -444,17 +688,33 @@ function renderDrizzleSchema(schema, options) {
   const coreImports = drizzleImports(options.dialect, manifest).join(", ");
   const tableFactory = options.dialect === "pg" ? "pgTable" : options.dialect === "mysql" ? "mysqlTable" : "sqliteTable";
   const modelBlocks = Object.values(manifest.models).map((model2) => {
+    const indexedFields = constrainedFields(model2);
     const lines = Object.values(model2.fields).map((field) => {
-      let value = drizzleColumn(field, options.dialect);
+      let value = drizzleColumn(field, options.dialect, { indexed: indexedFields.has(field.name) });
       if (field.references) {
         const [targetModel, targetField] = field.references.split(".");
         value += `.references(() => ${targetModel}.${targetField})`;
       }
       return `  ${field.name}: ${value}`;
     });
-    return `export const ${model2.name} = ${tableFactory}("${model2.table}", {
+    const constraintLines = [
+      ...model2.constraints.unique.map(
+        (constraint) => `  ${drizzleConstraintProperty(constraint)}: uniqueIndex("${constraint.name}").on(${constraint.fields.map((fieldName) => `table.${fieldName}`).join(", ")})`
+      ),
+      ...model2.constraints.indexes.map(
+        (constraint) => `  ${drizzleConstraintProperty(constraint)}: index("${constraint.name}").on(${constraint.fields.map((fieldName) => `table.${fieldName}`).join(", ")})`
+      )
+    ];
+    if (!constraintLines.length) {
+      return `export const ${model2.name} = ${tableFactory}("${model2.table}", {
 ${lines.join(",\n")}
 });`;
+    }
+    return `export const ${model2.name} = ${tableFactory}("${model2.table}", {
+${lines.join(",\n")}
+}, (table) => ({
+${constraintLines.join(",\n")}
+}));`;
   });
   const relationBlocks = Object.values(manifest.models).map((model2) => {
     const lines = Object.entries(model2.relations).flatMap(([relationName, relation]) => {
@@ -493,10 +753,13 @@ ${[...modelBlocks, ...relationBlocks].join("\n\n")}
 }
 function renderSafeSql(schema, options) {
   const manifest = createManifest(schema);
-  const statements = Object.values(manifest.models).map((model2) => {
+  const statements = Object.values(manifest.models).flatMap((model2) => {
+    const indexedFields = constrainedFields(model2);
     const columns = Object.values(model2.fields).map((field) => {
       const parts = [
-        `${sqlIdentifier(options.dialect, field.column)} ${sqlType(field, options.dialect)}`
+        `${sqlIdentifier(options.dialect, field.column)} ${sqlType(field, options.dialect, {
+          indexed: indexedFields.has(field.name)
+        })}`
       ];
       if (field.kind === "id") parts.push("primary key");
       if (!field.nullable) parts.push("not null");
@@ -519,9 +782,17 @@ function renderSafeSql(schema, options) {
       }
       return `  ${parts.join(" ")}`;
     });
-    return `create table if not exists ${sqlIdentifier(options.dialect, model2.table)} (
+    return [
+      `create table if not exists ${sqlIdentifier(options.dialect, model2.table)} (
 ${columns.join(",\n")}
-);`;
+);`,
+      ...model2.constraints.unique.map(
+        (constraint) => sqlCreateIndexStatement(options.dialect, model2.table, constraint)
+      ),
+      ...model2.constraints.indexes.map(
+        (constraint) => sqlCreateIndexStatement(options.dialect, model2.table, constraint)
+      )
+    ];
   });
   return `${statements.join("\n\n")}
 `;
@@ -545,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;
@@ -737,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);
@@ -768,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);
     },
@@ -845,6 +1149,7 @@ function model(config) {
     table: config.table,
     fields: config.fields,
     relations: config.relations ?? {},
+    constraints: config.constraints ?? {},
     description: config.description
   };
 }
@@ -868,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