@farming-labs/orm 0.0.9 → 0.0.11

package/dist/index.d.ts

@@ -1,4 +1,7 @@
-type ScalarKind = "id" | "string" | "boolean" | "datetime";
+type ScalarKind = "id" | "string" | "boolean" | "datetime" | "integer" | "json";
+type JsonValue = null | string | number | boolean | {
+    [key: string]: JsonValue;
+} | JsonValue[];
 type FieldReference = `${string}.${string}`;
 type FieldConfig<Kind extends ScalarKind = ScalarKind, Nullable extends boolean = boolean> = {
     kind: Kind;
@@ -10,25 +13,33 @@ type FieldConfig<Kind extends ScalarKind = ScalarKind, Nullable extends boolean
     references?: FieldReference;
     description?: string;
 };
-type AnyFieldBuilder = FieldBuilder<ScalarKind, boolean>;
-declare class FieldBuilder<Kind extends ScalarKind, Nullable extends boolean = false> {
+type ScalarValue<Kind extends ScalarKind> = Kind extends "id" ? string : Kind extends "string" ? string : Kind extends "boolean" ? boolean : Kind extends "datetime" ? Date : Kind extends "integer" ? number : JsonValue;
+type AnyFieldBuilder = FieldBuilder<ScalarKind, boolean, ScalarValue<ScalarKind>>;
+declare class FieldBuilder<Kind extends ScalarKind, Nullable extends boolean = false, Value = ScalarValue<Kind>> {
     readonly config: FieldConfig<Kind, Nullable>;
     readonly _tag = "field";
+    readonly __kind?: Kind;
+    readonly __nullable?: Nullable;
+    readonly __value?: Value;
     constructor(config: FieldConfig<Kind, Nullable>);
-    unique(): FieldBuilder<Kind, Nullable>;
-    nullable(): FieldBuilder<Kind, true>;
-    default(value: unknown): FieldBuilder<Kind, Nullable>;
-    defaultNow(): FieldBuilder<Kind, Nullable>;
-    references(reference: FieldReference): FieldBuilder<Kind, Nullable>;
-    map(name: string): FieldBuilder<Kind, Nullable>;
-    describe(description: string): FieldBuilder<Kind, Nullable>;
+    unique(): FieldBuilder<Kind, Nullable, ScalarValue<Kind>>;
+    nullable(): FieldBuilder<Kind, true, Value>;
+    default(value: unknown): FieldBuilder<Kind, Nullable, ScalarValue<Kind>>;
+    defaultNow(): FieldBuilder<Kind, Nullable, ScalarValue<Kind>>;
+    references(reference: FieldReference): FieldBuilder<Kind, Nullable, ScalarValue<Kind>>;
+    map(name: string): FieldBuilder<Kind, Nullable, ScalarValue<Kind>>;
+    describe(description: string): FieldBuilder<Kind, Nullable, ScalarValue<Kind>>;
 }
-type ScalarValue<Kind extends ScalarKind> = Kind extends "id" ? string : Kind extends "string" ? string : Kind extends "boolean" ? boolean : Date;
-type FieldOutput<TField> = TField extends FieldBuilder<infer Kind, infer Nullable> ? Nullable extends true ? ScalarValue<Kind> | null : ScalarValue<Kind> : never;
-declare function id(): FieldBuilder<"id", false>;
-declare function string(): FieldBuilder<"string", false>;
-declare function boolean(): FieldBuilder<"boolean", false>;
-declare function datetime(): FieldBuilder<"datetime", false>;
+type FieldOutput<TField> = TField extends {
+    __nullable?: infer Nullable;
+    __value?: infer Value;
+} ? Nullable extends true ? Value | null : Value : never;
+declare function id(): FieldBuilder<"id", false, string>;
+declare function string(): FieldBuilder<"string", false, string>;
+declare function boolean(): FieldBuilder<"boolean", false, boolean>;
+declare function datetime(): FieldBuilder<"datetime", false, Date>;
+declare function integer(): FieldBuilder<"integer", false, number>;
+declare function json<TValue extends JsonValue = JsonValue>(): FieldBuilder<"json", false, TValue>;
 
 type RelationKind = "belongsTo" | "hasOne" | "hasMany" | "manyToMany";
 type RelationDefinition<Target extends string = string, Kind extends RelationKind = RelationKind> = Kind extends "manyToMany" ? {
@@ -121,7 +132,6 @@ type RelationForName<TSchema, TName extends ModelName<TSchema>, TRelationName ex
 type RelationTarget<TSchema, TName extends ModelName<TSchema>, TRelationName extends RelationName<TSchema, TName>> = RelationForName<TSchema, TName, TRelationName> extends RelationDefinition<infer Target, any> ? Extract<Target, ModelName<TSchema>> : never;
 
 type Direction = "asc" | "desc";
-type Primitive = string | number | boolean | Date | null;
 type Comparable = string | number | Date;
 type ValueFilter<T> = T extends string ? T | {
     eq?: T;
@@ -141,7 +151,7 @@ type ValueFilter<T> = T extends string ? T | {
     in?: T[];
     not?: T;
 };
-type Where<TRecord extends Record<string, Primitive>> = {
+type Where<TRecord extends Record<string, unknown>> = {
     [K in keyof TRecord]?: ValueFilter<TRecord[K]>;
 } & {
     AND?: Array<Where<TRecord>>;
@@ -309,9 +319,26 @@ type ManifestModel = {
 type SchemaManifest = {
     models: Record<string, ManifestModel>;
 };
+type ManifestUniqueLookup = {
+    kind: "id" | "field" | "constraint";
+    fields: ManifestField[];
+    values: Record<string, unknown>;
+    constraint?: ManifestConstraint;
+};
+declare function isOperatorFilterObject(value: unknown): value is Record<string, unknown>;
+declare function equalValues(left: unknown, right: unknown): boolean;
+declare function requireUniqueLookup(model: ManifestModel, where: Record<string, unknown>, operation: string): ManifestUniqueLookup;
+declare function resolveRowIdentityLookup(model: ManifestModel, row: Record<string, unknown>): ManifestUniqueLookup;
+declare function toUniqueLookupWhere(lookup: ManifestUniqueLookup): {
+    [k: string]: unknown;
+};
+declare function mergeUniqueLookupCreateData(model: ManifestModel, createData: Partial<Record<string, unknown>>, lookup: ManifestUniqueLookup, operation: string): {
+    [x: string]: unknown;
+};
+declare function validateUniqueLookupUpdateData(model: ManifestModel, updateData: Partial<Record<string, unknown>>, lookup: ManifestUniqueLookup, operation: string): void;
 declare function createManifest<TSchema extends SchemaDefinition<Record<string, AnyModelDefinition>>>(schema: TSchema): SchemaManifest;
 
 type MemoryStore<TSchema extends SchemaDefinition<any>> = Partial<Record<ModelName<TSchema>, Array<Record<string, unknown>>>>;
 declare function createMemoryDriver<TSchema extends SchemaDefinition<any>>(seed?: MemoryStore<TSchema>): OrmDriver<TSchema>;
 
-export { type AnyFieldBuilder, type AnyModelDefinition, type AnyRelation, type BatchTask, type ConstraintFieldName, type ConstraintFieldSet, type CountArgs, type CreateArgs, type CreateManyArgs, type DeleteArgs, type DeleteManyArgs, type DrizzleGenerationOptions, FieldBuilder, type FieldConfig, type FieldMap, type FieldOutput, type FieldReference, type FindFirstArgs, type FindManyArgs, type FindOneArgs, type FindUniqueArgs, type ManifestConstraint, type ManifestField, type ManifestModel, type ModelClient, type ModelConstraints, type ModelDefinition, type ModelFields, type ModelForName, type ModelName, type ModelRelations, type OrmClient, type OrmDriver, type PrismaGenerationOptions, type RelationDefinition, type RelationForName, type RelationKind, type RelationMap, type RelationName, type RelationTarget, type ScalarKind, type ScalarRecord, type ScalarValue, type SchemaDefinition, type SchemaManifest, type SchemaModels, type SelectShape, type SelectedRecord, type SqlGenerationOptions, type UpdateArgs, type UpdateManyArgs, type UpsertArgs, type Where, belongsTo, boolean, createManifest, createMemoryDriver, createOrm, datetime, defineSchema, hasMany, hasOne, id, manyToMany, model, renderDrizzleSchema, renderPrismaSchema, renderSafeSql, replaceGeneratedBlock, string };
+export { type AnyFieldBuilder, type AnyModelDefinition, type AnyRelation, type BatchTask, type ConstraintFieldName, type ConstraintFieldSet, type CountArgs, type CreateArgs, type CreateManyArgs, type DeleteArgs, type DeleteManyArgs, type DrizzleGenerationOptions, FieldBuilder, type FieldConfig, type FieldMap, type FieldOutput, type FieldReference, type FindFirstArgs, type FindManyArgs, type FindOneArgs, type FindUniqueArgs, type JsonValue, type ManifestConstraint, type ManifestField, type ManifestModel, type ManifestUniqueLookup, type ModelClient, type ModelConstraints, type ModelDefinition, type ModelFields, type ModelForName, type ModelName, type ModelRelations, type OrmClient, type OrmDriver, type PrismaGenerationOptions, type RelationDefinition, type RelationForName, type RelationKind, type RelationMap, type RelationName, type RelationTarget, type ScalarKind, type ScalarRecord, type ScalarValue, type SchemaDefinition, type SchemaManifest, type SchemaModels, type SelectShape, type SelectedRecord, type SqlGenerationOptions, type UpdateArgs, type UpdateManyArgs, type UpsertArgs, type Where, belongsTo, boolean, createManifest, createMemoryDriver, createOrm, datetime, defineSchema, equalValues, hasMany, hasOne, id, integer, isOperatorFilterObject, json, manyToMany, mergeUniqueLookupCreateData, model, renderDrizzleSchema, renderPrismaSchema, renderSafeSql, replaceGeneratedBlock, requireUniqueLookup, resolveRowIdentityLookup, string, toUniqueLookupWhere, validateUniqueLookupUpdateData };

package/dist/index.js

@@ -70,6 +70,9 @@ var FieldBuilder = class {
     this.config = config;
   }
   _tag = "field";
+  __kind;
+  __nullable;
+  __value;
   unique() {
     return cloneField({
       ...this.config,
@@ -142,8 +145,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
+import { isDeepStrictEqual } from "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 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}`;
@@ -254,6 +438,10 @@ function prismaType(field) {
       return "Boolean";
     case "datetime":
       return "DateTime";
+    case "integer":
+      return "Int";
+    case "json":
+      return "Json";
   }
 }
 function drizzleConstraintProperty(constraint) {
@@ -274,6 +462,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
   );
@@ -282,7 +476,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);
@@ -293,7 +489,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);
@@ -307,6 +505,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()`;
@@ -316,15 +518,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()"}`;
@@ -344,6 +561,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";
   }
@@ -397,7 +622,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)})`
         );
@@ -555,7 +780,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)}`
         );
@@ -606,17 +831,24 @@ ${block}
 
 // src/memory.ts
 import { randomUUID } from "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;
@@ -799,6 +1031,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);
@@ -830,12 +1067,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);
     },
@@ -926,15 +1183,24 @@ export {
   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.js.map