@farming-labs/orm 0.0.1 → 0.0.2

package/dist/index.d.cts

@@ -168,37 +168,79 @@ type FindManyArgs<TSchema extends SchemaDefinition<any>, TModelName extends Mode
     skip?: number;
 };
 type FindFirstArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined> = FindManyArgs<TSchema, TModelName, TSelect>;
+type FindOneArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined> = FindFirstArgs<TSchema, TModelName, TSelect>;
+type FindUniqueArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined> = {
+    where: Where<ScalarRecord<TSchema, TModelName>>;
+    select?: TSelect;
+};
 type CreateArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined> = {
     data: Partial<ScalarRecord<TSchema, TModelName>>;
     select?: TSelect;
 };
+type CreateManyArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined> = {
+    data: Array<Partial<ScalarRecord<TSchema, TModelName>>>;
+    select?: TSelect;
+};
 type UpdateArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined> = {
     where: Where<ScalarRecord<TSchema, TModelName>>;
     data: Partial<ScalarRecord<TSchema, TModelName>>;
     select?: TSelect;
 };
+type UpdateManyArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>> = {
+    where: Where<ScalarRecord<TSchema, TModelName>>;
+    data: Partial<ScalarRecord<TSchema, TModelName>>;
+};
 type DeleteArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>> = {
     where: Where<ScalarRecord<TSchema, TModelName>>;
 };
+type DeleteManyArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>> = {
+    where: Where<ScalarRecord<TSchema, TModelName>>;
+};
+type CountArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>> = {
+    where?: Where<ScalarRecord<TSchema, TModelName>>;
+};
+type UpsertArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined> = {
+    where: Where<ScalarRecord<TSchema, TModelName>>;
+    create: Partial<ScalarRecord<TSchema, TModelName>>;
+    update: Partial<ScalarRecord<TSchema, TModelName>>;
+    select?: TSelect;
+};
 interface OrmDriver<TSchema extends SchemaDefinition<any>> {
     findMany<TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(schema: TSchema, model: TModelName, args: FindManyArgs<TSchema, TModelName, TSelect>): Promise<Array<SelectedRecord<TSchema, TModelName, TSelect>>>;
     findFirst<TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(schema: TSchema, model: TModelName, args: FindFirstArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect> | null>;
+    findUnique<TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(schema: TSchema, model: TModelName, args: FindUniqueArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect> | null>;
+    count<TModelName extends ModelName<TSchema>>(schema: TSchema, model: TModelName, args?: CountArgs<TSchema, TModelName>): Promise<number>;
     create<TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(schema: TSchema, model: TModelName, args: CreateArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect>>;
+    createMany<TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(schema: TSchema, model: TModelName, args: CreateManyArgs<TSchema, TModelName, TSelect>): Promise<Array<SelectedRecord<TSchema, TModelName, TSelect>>>;
     update<TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(schema: TSchema, model: TModelName, args: UpdateArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect> | null>;
+    updateMany<TModelName extends ModelName<TSchema>>(schema: TSchema, model: TModelName, args: UpdateManyArgs<TSchema, TModelName>): Promise<number>;
+    upsert<TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(schema: TSchema, model: TModelName, args: UpsertArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect>>;
     delete<TModelName extends ModelName<TSchema>>(schema: TSchema, model: TModelName, args: DeleteArgs<TSchema, TModelName>): Promise<number>;
+    deleteMany<TModelName extends ModelName<TSchema>>(schema: TSchema, model: TModelName, args: DeleteManyArgs<TSchema, TModelName>): Promise<number>;
     transaction<TResult>(schema: TSchema, run: (driver: OrmDriver<TSchema>) => Promise<TResult>): Promise<TResult>;
 }
 type ModelClient<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>> = {
     findMany<TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(args?: FindManyArgs<TSchema, TModelName, TSelect>): Promise<Array<SelectedRecord<TSchema, TModelName, TSelect>>>;
+    findOne<TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(args?: FindOneArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect> | null>;
     findFirst<TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(args?: FindFirstArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect> | null>;
+    findUnique<TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(args: FindUniqueArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect> | null>;
+    count(args?: CountArgs<TSchema, TModelName>): Promise<number>;
     create<TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(args: CreateArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect>>;
+    createMany<TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(args: CreateManyArgs<TSchema, TModelName, TSelect>): Promise<Array<SelectedRecord<TSchema, TModelName, TSelect>>>;
     update<TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(args: UpdateArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect> | null>;
+    updateMany(args: UpdateManyArgs<TSchema, TModelName>): Promise<number>;
+    upsert<TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(args: UpsertArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect>>;
     delete(args: DeleteArgs<TSchema, TModelName>): Promise<number>;
+    deleteMany(args: DeleteManyArgs<TSchema, TModelName>): Promise<number>;
 };
+type BatchTask<TSchema extends SchemaDefinition<any>, TResult> = (tx: OrmClient<TSchema>) => Promise<TResult>;
 type OrmClient<TSchema extends SchemaDefinition<any>> = {
     [K in ModelName<TSchema>]: ModelClient<TSchema, K>;
 } & {
     transaction<TResult>(run: (tx: OrmClient<TSchema>) => Promise<TResult>): Promise<TResult>;
+    batch<const TResult extends readonly unknown[]>(tasks: {
+        [K in keyof TResult]: BatchTask<TSchema, TResult[K]>;
+    }): Promise<TResult>;
 };
 declare function createOrm<TSchema extends SchemaDefinition<any>>(options: {
     schema: TSchema;
@@ -251,4 +293,4 @@ declare function createManifest<TSchema extends SchemaDefinition<Record<string,
 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 CreateArgs, type DeleteArgs, type DrizzleGenerationOptions, FieldBuilder, type FieldConfig, type FieldMap, type FieldOutput, type FieldReference, type FindFirstArgs, type FindManyArgs, type ManifestField, type ManifestModel, type ModelClient, 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 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 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 ManifestField, type ManifestModel, type ModelClient, 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 };

package/dist/index.d.ts

@@ -168,37 +168,79 @@ type FindManyArgs<TSchema extends SchemaDefinition<any>, TModelName extends Mode
     skip?: number;
 };
 type FindFirstArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined> = FindManyArgs<TSchema, TModelName, TSelect>;
+type FindOneArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined> = FindFirstArgs<TSchema, TModelName, TSelect>;
+type FindUniqueArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined> = {
+    where: Where<ScalarRecord<TSchema, TModelName>>;
+    select?: TSelect;
+};
 type CreateArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined> = {
     data: Partial<ScalarRecord<TSchema, TModelName>>;
     select?: TSelect;
 };
+type CreateManyArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined> = {
+    data: Array<Partial<ScalarRecord<TSchema, TModelName>>>;
+    select?: TSelect;
+};
 type UpdateArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined> = {
     where: Where<ScalarRecord<TSchema, TModelName>>;
     data: Partial<ScalarRecord<TSchema, TModelName>>;
     select?: TSelect;
 };
+type UpdateManyArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>> = {
+    where: Where<ScalarRecord<TSchema, TModelName>>;
+    data: Partial<ScalarRecord<TSchema, TModelName>>;
+};
 type DeleteArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>> = {
     where: Where<ScalarRecord<TSchema, TModelName>>;
 };
+type DeleteManyArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>> = {
+    where: Where<ScalarRecord<TSchema, TModelName>>;
+};
+type CountArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>> = {
+    where?: Where<ScalarRecord<TSchema, TModelName>>;
+};
+type UpsertArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined> = {
+    where: Where<ScalarRecord<TSchema, TModelName>>;
+    create: Partial<ScalarRecord<TSchema, TModelName>>;
+    update: Partial<ScalarRecord<TSchema, TModelName>>;
+    select?: TSelect;
+};
 interface OrmDriver<TSchema extends SchemaDefinition<any>> {
     findMany<TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(schema: TSchema, model: TModelName, args: FindManyArgs<TSchema, TModelName, TSelect>): Promise<Array<SelectedRecord<TSchema, TModelName, TSelect>>>;
     findFirst<TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(schema: TSchema, model: TModelName, args: FindFirstArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect> | null>;
+    findUnique<TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(schema: TSchema, model: TModelName, args: FindUniqueArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect> | null>;
+    count<TModelName extends ModelName<TSchema>>(schema: TSchema, model: TModelName, args?: CountArgs<TSchema, TModelName>): Promise<number>;
     create<TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(schema: TSchema, model: TModelName, args: CreateArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect>>;
+    createMany<TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(schema: TSchema, model: TModelName, args: CreateManyArgs<TSchema, TModelName, TSelect>): Promise<Array<SelectedRecord<TSchema, TModelName, TSelect>>>;
     update<TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(schema: TSchema, model: TModelName, args: UpdateArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect> | null>;
+    updateMany<TModelName extends ModelName<TSchema>>(schema: TSchema, model: TModelName, args: UpdateManyArgs<TSchema, TModelName>): Promise<number>;
+    upsert<TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(schema: TSchema, model: TModelName, args: UpsertArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect>>;
     delete<TModelName extends ModelName<TSchema>>(schema: TSchema, model: TModelName, args: DeleteArgs<TSchema, TModelName>): Promise<number>;
+    deleteMany<TModelName extends ModelName<TSchema>>(schema: TSchema, model: TModelName, args: DeleteManyArgs<TSchema, TModelName>): Promise<number>;
     transaction<TResult>(schema: TSchema, run: (driver: OrmDriver<TSchema>) => Promise<TResult>): Promise<TResult>;
 }
 type ModelClient<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>> = {
     findMany<TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(args?: FindManyArgs<TSchema, TModelName, TSelect>): Promise<Array<SelectedRecord<TSchema, TModelName, TSelect>>>;
+    findOne<TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(args?: FindOneArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect> | null>;
     findFirst<TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(args?: FindFirstArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect> | null>;
+    findUnique<TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(args: FindUniqueArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect> | null>;
+    count(args?: CountArgs<TSchema, TModelName>): Promise<number>;
     create<TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(args: CreateArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect>>;
+    createMany<TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(args: CreateManyArgs<TSchema, TModelName, TSelect>): Promise<Array<SelectedRecord<TSchema, TModelName, TSelect>>>;
     update<TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(args: UpdateArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect> | null>;
+    updateMany(args: UpdateManyArgs<TSchema, TModelName>): Promise<number>;
+    upsert<TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(args: UpsertArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect>>;
     delete(args: DeleteArgs<TSchema, TModelName>): Promise<number>;
+    deleteMany(args: DeleteManyArgs<TSchema, TModelName>): Promise<number>;
 };
+type BatchTask<TSchema extends SchemaDefinition<any>, TResult> = (tx: OrmClient<TSchema>) => Promise<TResult>;
 type OrmClient<TSchema extends SchemaDefinition<any>> = {
     [K in ModelName<TSchema>]: ModelClient<TSchema, K>;
 } & {
     transaction<TResult>(run: (tx: OrmClient<TSchema>) => Promise<TResult>): Promise<TResult>;
+    batch<const TResult extends readonly unknown[]>(tasks: {
+        [K in keyof TResult]: BatchTask<TSchema, TResult[K]>;
+    }): Promise<TResult>;
 };
 declare function createOrm<TSchema extends SchemaDefinition<any>>(options: {
     schema: TSchema;
@@ -251,4 +293,4 @@ declare function createManifest<TSchema extends SchemaDefinition<Record<string,
 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 CreateArgs, type DeleteArgs, type DrizzleGenerationOptions, FieldBuilder, type FieldConfig, type FieldMap, type FieldOutput, type FieldReference, type FindFirstArgs, type FindManyArgs, type ManifestField, type ManifestModel, type ModelClient, 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 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 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 ManifestField, type ManifestModel, type ModelClient, 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 };

package/dist/index.js

@@ -4,17 +4,38 @@ function createModelClient(schema, driver, model2) {
     findMany(args) {
       return driver.findMany(schema, model2, args ?? {});
     },
+    findOne(args) {
+      return driver.findFirst(schema, model2, args ?? {});
+    },
     findFirst(args) {
       return driver.findFirst(schema, model2, args ?? {});
     },
+    findUnique(args) {
+      return driver.findUnique(schema, model2, args);
+    },
+    count(args) {
+      return driver.count(schema, model2, args);
+    },
     create(args) {
       return driver.create(schema, model2, args);
     },
+    createMany(args) {
+      return driver.createMany(schema, model2, args);
+    },
     update(args) {
       return driver.update(schema, model2, args);
     },
+    updateMany(args) {
+      return driver.updateMany(schema, model2, args);
+    },
+    upsert(args) {
+      return driver.upsert(schema, model2, args);
+    },
     delete(args) {
       return driver.delete(schema, model2, args);
+    },
+    deleteMany(args) {
+      return driver.deleteMany(schema, model2, args);
     }
   };
 }
@@ -32,6 +53,13 @@ function createOrm(options) {
     });
     return run(tx);
   });
+  orm.batch = async (tasks) => orm.transaction(async (tx) => {
+    const results = [];
+    for (const task of tasks) {
+      results.push(await task(tx));
+    }
+    return results;
+  });
   return orm;
 }
 
@@ -226,7 +254,7 @@ function sqlType(field, dialect) {
     return dialect === "mysql" ? "varchar(191)" : "text";
   }
   if (field.kind === "string") {
-    return dialect === "mysql" && field.unique ? "varchar(191)" : "text";
+    return dialect === "mysql" && (field.unique || field.references) ? "varchar(191)" : "text";
   }
   if (field.kind === "boolean") {
     return dialect === "sqlite" ? "integer" : "boolean";
@@ -239,6 +267,12 @@ function sqlType(field, dialect) {
   }
   return "timestamp";
 }
+function sqlIdentifier(dialect, value) {
+  if (dialect === "mysql") {
+    return `\`${value}\``;
+  }
+  return `"${value}"`;
+}
 function renderPrismaSchema(schema, options = {}) {
   const manifest = createManifest(schema);
   const provider = options.provider ?? "postgresql";
@@ -333,7 +367,9 @@ function renderSafeSql(schema, options) {
   const manifest = createManifest(schema);
   const statements = Object.values(manifest.models).map((model2) => {
     const columns = Object.values(model2.fields).map((field) => {
-      const parts = [`${field.column} ${sqlType(field, options.dialect)}`];
+      const parts = [
+        `${sqlIdentifier(options.dialect, field.column)} ${sqlType(field, options.dialect)}`
+      ];
       if (field.kind === "id") parts.push("primary key");
       if (!field.nullable) parts.push("not null");
       if (field.unique && field.kind !== "id") parts.push("unique");
@@ -345,11 +381,17 @@ function renderSafeSql(schema, options) {
       if (field.references) {
         const [targetModel, targetField] = field.references.split(".");
         const targetTable = manifest.models[targetModel]?.table ?? targetModel;
-        parts.push(`references ${targetTable}(${targetField})`);
+        const targetColumn = manifest.models[targetModel]?.fields[targetField]?.column ?? targetField;
+        parts.push(
+          `references ${sqlIdentifier(options.dialect, targetTable)}(${sqlIdentifier(
+            options.dialect,
+            targetColumn
+          )})`
+        );
       }
       return `  ${parts.join(" ")}`;
     });
-    return `create table if not exists ${model2.table} (
+    return `create table if not exists ${sqlIdentifier(options.dialect, model2.table)} (
 ${columns.join(",\n")}
 );`;
   });
@@ -466,6 +508,11 @@ function pageRows(rows, skip, take) {
   const end = take === void 0 ? void 0 : start + take;
   return rows.slice(start, end);
 }
+function applyQuery(rows, args = {}) {
+  const filtered = rows.filter((row) => matchesWhere(row, args.where));
+  const sorted = sortRows(filtered, args.orderBy);
+  return pageRows(sorted, args.skip, args.take);
+}
 function createMemoryDriver(seed) {
   const state = structuredClone(seed ?? {});
   function getRows(model2) {
@@ -473,14 +520,13 @@ function createMemoryDriver(seed) {
     state[model2] = rows;
     return rows;
   }
-  function applyQuery(model2, args) {
-    const rows = getRows(model2);
-    const filtered = rows.filter((row) => matchesWhere(row, args.where));
-    const sorted = sortRows(
-      filtered,
-      args.orderBy
-    );
-    return pageRows(sorted, args.skip, args.take);
+  function buildRow(schema, model2, data) {
+    const modelDefinition = schema.models[model2];
+    const nextRow = {};
+    for (const [fieldName, field] of Object.entries(modelDefinition.fields)) {
+      nextRow[fieldName] = applyDefault(data[fieldName], field.config);
+    }
+    return nextRow;
   }
   async function projectRow(schema, model2, row, select) {
     const modelDefinition = schema.models[model2];
@@ -513,28 +559,27 @@ function createMemoryDriver(seed) {
     const relation = schema.models[model2].relations[relationName];
     const relationArgs = value === true ? {} : value;
     if (relation.kind === "belongsTo") {
-      const targetRows2 = getRows(relation.target);
       const foreignValue = row[relation.foreignKey];
-      const target = targetRows2.find((item) => item.id === foreignValue);
+      const targetRows2 = getRows(relation.target).filter(
+        (item) => item.id === foreignValue
+      );
+      const target = applyQuery(targetRows2, relationArgs)[0];
       return target ? projectRow(schema, relation.target, target, relationArgs.select) : null;
     }
     if (relation.kind === "hasOne") {
-      const targetRows2 = getRows(relation.target);
-      const target = targetRows2.find((item) => item[relation.foreignKey] === row.id);
+      const targetRows2 = getRows(relation.target).filter(
+        (item) => item[relation.foreignKey] === row.id
+      );
+      const target = applyQuery(targetRows2, relationArgs)[0];
       return target ? projectRow(schema, relation.target, target, relationArgs.select) : null;
     }
     if (relation.kind === "hasMany") {
       const targetRows2 = getRows(relation.target).filter(
         (item) => item[relation.foreignKey] === row.id
       );
-      const sorted2 = sortRows(
-        targetRows2,
-        relationArgs.orderBy
-      );
-      const paged2 = pageRows(sorted2, relationArgs.skip, relationArgs.take);
-      const filtered2 = paged2.filter((item) => matchesWhere(item, relationArgs.where));
+      const matchedRows2 = applyQuery(targetRows2, relationArgs);
       return Promise.all(
-        filtered2.map(
+        matchedRows2.map(
           (item) => projectRow(schema, relation.target, item, relationArgs.select)
         )
       );
@@ -546,45 +591,72 @@ function createMemoryDriver(seed) {
     const targetRows = getRows(relation.target).filter(
       (item) => targetIds.includes(item.id)
     );
-    const sorted = sortRows(
-      targetRows,
-      relationArgs.orderBy
-    );
-    const paged = pageRows(sorted, relationArgs.skip, relationArgs.take);
-    const filtered = paged.filter((item) => matchesWhere(item, relationArgs.where));
+    const matchedRows = applyQuery(targetRows, relationArgs);
     return Promise.all(
-      filtered.map(
+      matchedRows.map(
         (item) => projectRow(schema, relation.target, item, relationArgs.select)
       )
     );
   }
   const driver = {
     async findMany(schema, model2, args) {
-      const rows = applyQuery(model2, args);
+      const rows = applyQuery(getRows(model2), args);
       return Promise.all(rows.map((row) => projectRow(schema, model2, row, args.select)));
     },
     async findFirst(schema, model2, args) {
-      const row = applyQuery(model2, args)[0];
+      const row = applyQuery(getRows(model2), args)[0];
       if (!row) return null;
       return projectRow(schema, model2, row, args.select);
     },
+    async findUnique(schema, model2, args) {
+      const row = applyQuery(getRows(model2), args)[0];
+      if (!row) return null;
+      return projectRow(schema, model2, row, args.select);
+    },
+    async count(_schema, model2, args) {
+      return applyQuery(getRows(model2), args).length;
+    },
     async create(schema, model2, args) {
-      const modelDefinition = schema.models[model2];
-      const nextRow = {};
-      for (const [fieldName, field] of Object.entries(modelDefinition.fields)) {
-        nextRow[fieldName] = applyDefault(args.data[fieldName], field.config);
-      }
+      const nextRow = buildRow(schema, model2, args.data);
       getRows(model2).push(nextRow);
       return projectRow(schema, model2, nextRow, args.select);
     },
+    async createMany(schema, model2, args) {
+      const rows = args.data.map((entry) => buildRow(schema, model2, entry));
+      getRows(model2).push(...rows);
+      return Promise.all(rows.map((row) => projectRow(schema, model2, row, args.select)));
+    },
     async update(schema, model2, args) {
-      const rows = getRows(model2);
-      const row = rows.find((item) => matchesWhere(item, args.where));
+      const row = getRows(model2).find((item) => matchesWhere(item, args.where));
       if (!row) return null;
       Object.assign(row, args.data);
       return projectRow(schema, model2, row, args.select);
     },
+    async updateMany(_schema, model2, args) {
+      const rows = getRows(model2).filter((item) => matchesWhere(item, args.where));
+      for (const row of rows) {
+        Object.assign(row, args.data);
+      }
+      return rows.length;
+    },
+    async upsert(schema, model2, args) {
+      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);
+      getRows(model2).push(created);
+      return projectRow(schema, model2, created, args.select);
+    },
     async delete(_schema, model2, args) {
+      const rows = getRows(model2);
+      const index = rows.findIndex((item) => matchesWhere(item, args.where));
+      if (index === -1) return 0;
+      rows.splice(index, 1);
+      return 1;
+    },
+    async deleteMany(_schema, model2, args) {
       const rows = getRows(model2);
       const before = rows.length;
       state[model2] = rows.filter((item) => !matchesWhere(item, args.where));