@effectify/prisma 1.0.1 → 1.1.0

package/dist/src/services/generator-service.js

@@ -1,20 +1,25 @@
-import * as FileSystem from '@effect/platform/FileSystem';
-import * as Path from '@effect/platform/Path';
-import * as Context from 'effect/Context';
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-import { GeneratorContext } from './generator-context.js';
-import { RenderService } from './render-service.js';
-export class GeneratorService extends Context.Tag('GeneratorService')() {
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Path from "@effect/platform/Path";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { GeneratorContext } from "./generator-context.js";
+import { RenderService } from "./render-service.js";
+import { FormatterService } from "./formatter-service.js";
+import { generateSchemas } from "../schema-generator/index.js";
+export class GeneratorService extends Context.Tag("GeneratorService")() {
     static Live = Layer.effect(GeneratorService, Effect.gen(function* () {
         const fs = yield* FileSystem.FileSystem;
         const path = yield* Path.Path;
-        const { render } = yield* RenderService;
+        const renderService = yield* RenderService;
+        const formatterService = yield* FormatterService;
+        const { render } = renderService;
+        const { format } = formatterService;
         const parseErrorImportPath = (errorImportPath) => {
             if (!errorImportPath) {
                 return null;
             }
-            const [modulePath, className] = errorImportPath.split('#');
+            const [modulePath, className] = errorImportPath.split("#");
             if (!(modulePath && className)) {
                 throw new Error(`Invalid errorImportPath format: "${errorImportPath}". Expected "path/to/module#ErrorClassName"`);
             }
@@ -30,36 +35,21 @@ export class GeneratorService extends Context.Tag('GeneratorService')() {
             }
             return `${filePath}.${extension}`;
         };
-        const fixSchemaImports = (outputDir) => Effect.gen(function* () {
-            const schemasDir = path.join(outputDir, 'schemas');
-            const indexFile = path.join(schemasDir, 'index.ts');
-            const exists = yield* fs.exists(indexFile);
-            if (!exists) {
-                return;
-            }
-            const content = yield* fs.readFileString(indexFile);
-            const fixedContent = content
-                .replace(/export \* from '\.\/enums'/g, "export * from './enums.js'")
-                .replace(/export \* from '\.\/types'/g, "export * from './types.js'");
-            if (content !== fixedContent) {
-                yield* fs.writeFileString(indexFile, fixedContent);
-            }
-        });
         const getClientImportPath = (config) => Array.isArray(config.clientImportPath)
             ? config.clientImportPath[0]
-            : (config.clientImportPath ?? '@prisma/client');
+            : (config.clientImportPath ?? "@prisma/client");
         const getErrorImportPath = (config) => Array.isArray(config.errorImportPath) ? config.errorImportPath[0] : config.errorImportPath;
-        const getImportFileExtension = (config) => Array.isArray(config.importFileExtension) ? config.importFileExtension[0] : (config.importFileExtension ?? '');
+        const getImportFileExtension = (config) => Array.isArray(config.importFileExtension) ? config.importFileExtension[0] : (config.importFileExtension ?? "");
         const getCustomError = (config, options, schemaDir) => {
             const errorImportPathRaw = getErrorImportPath(config);
             const importFileExtension = getImportFileExtension(config);
             let customError = parseErrorImportPath(errorImportPathRaw);
-            if (customError?.path.startsWith('.')) {
+            if (customError?.path.startsWith(".")) {
                 const outputDir = options.generator.output?.value;
                 if (outputDir) {
                     const absoluteErrorPath = path.resolve(schemaDir, customError.path);
                     const relativeToOutput = path.relative(outputDir, absoluteErrorPath);
-                    const normalizedPath = relativeToOutput.startsWith('.') ? relativeToOutput : `./${relativeToOutput}`;
+                    const normalizedPath = relativeToOutput.startsWith(".") ? relativeToOutput : `./${relativeToOutput}`;
                     const pathWithExtension = addExtension(normalizedPath, importFileExtension);
                     customError = { ...customError, path: pathWithExtension };
                 }
@@ -73,32 +63,36 @@ export class GeneratorService extends Context.Tag('GeneratorService')() {
             return { clientImportPath, customError };
         };
         const generatePrismaSchema = (outputDir) => Effect.gen(function* () {
-            const content = yield* render('prisma-schema', {});
-            yield* fs.writeFileString(path.join(outputDir, 'prisma-schema.ts'), content);
+            const content = yield* render("prisma-schema", {});
+            const formatted = yield* format(content);
+            yield* fs.writeFileString(path.join(outputDir, "prisma-schema.ts"), formatted);
         });
         const generatePrismaRepository = (outputDir, clientImportPath) => Effect.gen(function* () {
-            const content = yield* render('prisma-repository', { clientImportPath });
-            yield* fs.writeFileString(path.join(outputDir, 'prisma-repository.ts'), content);
+            const content = yield* render("prisma-repository", { clientImportPath });
+            const formatted = yield* format(content);
+            yield* fs.writeFileString(path.join(outputDir, "prisma-repository.ts"), formatted);
         });
         const generateModels = (outputDir, models) => Effect.gen(function* () {
-            yield* fs.makeDirectory(path.join(outputDir, 'models'), { recursive: true });
+            yield* fs.makeDirectory(path.join(outputDir, "models"), { recursive: true });
             for (const model of models) {
-                const content = yield* render('model', { model });
-                yield* fs.writeFileString(path.join(outputDir, 'models', `${model.name}.ts`), content);
+                const content = yield* render("model", { model });
+                const formatted = yield* format(content);
+                yield* fs.writeFileString(path.join(outputDir, "models", `${model.name}.ts`), formatted);
             }
         });
         const generateIndex = (outputDir, models, clientImportPath, customError) => Effect.gen(function* () {
-            const errorType = customError ? customError.className : 'PrismaError';
-            const rawSqlOperations = yield* render('prisma-raw-sql', { errorType });
-            const modelExports = models.map((m) => `export * from "./models/${m.name}.js"`).join('\n');
-            const templateName = customError ? 'index-custom-error' : 'index-default';
+            const errorType = customError ? customError.className : "PrismaError";
+            const rawSqlOperations = yield* render("prisma-raw-sql", { errorType });
+            const modelExports = models.map((m) => `export * from "./models/${m.name}.js"`).join("\n");
+            const templateName = customError ? "index-custom-error" : "index-default";
             const content = yield* render(templateName, {
                 clientImportPath,
                 customError,
                 rawSqlOperations,
                 modelExports,
             });
-            yield* fs.writeFileString(path.join(outputDir, 'index.ts'), content);
+            const formatted = yield* format(content);
+            yield* fs.writeFileString(path.join(outputDir, "index.ts"), formatted);
         });
         const generate = Effect.gen(function* () {
             const options = yield* GeneratorContext;
@@ -106,15 +100,17 @@ export class GeneratorService extends Context.Tag('GeneratorService')() {
             const outputDir = options.generator.output?.value;
             const schemaDir = path.dirname(options.schemaPath);
             if (!outputDir) {
-                return yield* Effect.fail(new Error('No output directory specified'));
+                return yield* Effect.fail(new Error("No output directory specified"));
             }
             const { clientImportPath, customError } = getGeneratorConfig(options, schemaDir);
             yield* fs.makeDirectory(outputDir, { recursive: true });
+            // Generate Effect/Kysely Schemas (enums.ts, types.ts, schemas/index.ts)
+            const schemasDir = path.join(outputDir, "schemas");
+            yield* generateSchemas(options.dmmf, schemasDir).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path), Effect.provideService(RenderService, renderService), Effect.provideService(FormatterService, formatterService));
             yield* generatePrismaSchema(outputDir);
             yield* generatePrismaRepository(outputDir, clientImportPath);
             yield* generateModels(outputDir, models);
             yield* generateIndex(outputDir, models, clientImportPath, customError);
-            yield* fixSchemaImports(outputDir);
         });
         return { generate };
     }));

package/dist/src/services/render-service.d.ts

@@ -1,6 +1,6 @@
-import * as Context from 'effect/Context';
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
 declare const RenderService_base: Context.TagClass<RenderService, "RenderService", {
     readonly render: (templateName: string, data: Record<string, unknown>) => Effect.Effect<string, Error>;
 }>;

package/dist/src/services/render-service.js

@@ -1,14 +1,14 @@
-import * as path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import * as Context from 'effect/Context';
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-import { Eta } from 'eta';
-export class RenderService extends Context.Tag('RenderService')() {
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { Eta } from "eta";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+export class RenderService extends Context.Tag("RenderService")() {
     static Live = Layer.sync(RenderService, () => {
         const __filename = fileURLToPath(import.meta.url);
         const __dirname = path.dirname(__filename);
-        const templatesDir = path.resolve(__dirname, '../templates');
+        const templatesDir = path.resolve(__dirname, "../templates");
         const eta = new Eta({
             views: templatesDir,
             autoEscape: false,

package/dist/src/templates/effect-branded-id.eta

@@ -0,0 +1,2 @@
+export const <%= it.name %>Id = <%~ it.baseType %>.pipe(Schema.brand("<%= it.name %>Id"));
+export type <%= it.name %>Id = typeof <%= it.name %>Id.Type;

package/dist/src/templates/effect-enums.eta

@@ -0,0 +1,9 @@
+<%~ it.header %>
+
+import { Schema } from "effect";
+
+<% it.enums.forEach(function(enumItem) { %>
+export const <%= enumItem.name %> = Schema.Literal(<%~ enumItem.values %>);
+export type <%= enumItem.name %> = typeof <%= enumItem.name %>.Type;
+
+<% }) %>

package/dist/src/templates/effect-index.eta

@@ -0,0 +1,4 @@
+export * from "./types.js";
+<% if (it.hasEnums) { %>
+export * from "./enums.js";
+<% } %>

package/dist/src/templates/effect-join-table.eta

@@ -0,0 +1,8 @@
+// <%= it.tableName %> Join Table Schema (Prisma implicit many-to-many)
+// Database columns: A (<%= it.modelA %>), B (<%= it.modelB %>)
+// TypeScript fields: <%= it.columnAFieldName %>, <%= it.columnBFieldName %>
+export const <%= it.name %> = Schema.Struct({
+<%~ it.columnAField %>,
+<%~ it.columnBField %>,
+});
+export type <%= it.name %> = typeof <%= it.name %>;

package/dist/src/templates/effect-model.eta

@@ -0,0 +1,6 @@
+export const <%= it.name %> = Schema.Struct({
+<% it.fields.forEach(function(field) { %>
+  <%= field.name %>: <%~ field.type %>,
+<% }) %>
+});
+export type <%= it.name %> = typeof <%= it.name %>;

package/dist/src/templates/effect-types-header.eta

@@ -0,0 +1,7 @@
+<%~ it.header %>
+
+import { Schema } from "effect";
+import { generated } from "@effectify/prisma";
+<% if (it.enumImports) { %>
+import { <%~ it.enumImports %> } from "./enums.js";
+<% } %>

package/dist/src/templates/index-default.eta

@@ -201,7 +201,8 @@ export type PrismaError =
 // Generic mapper for raw operations and fallback
 const mapError = (error: unknown, operation: string, model: string): PrismaError => {
   if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
+    const prismaError = error as PrismaNamespace.PrismaClientKnownRequestError;
+    switch (prismaError.code) {
       case "P2000":
         return new PrismaValueTooLongError({ cause: error, operation, model });
       case "P2002":

package/dist/src/templates/kysely-db-interface.eta

@@ -0,0 +1,6 @@
+// Kysely Database Interface
+export interface DB {
+<% it.models.forEach(function(model) { %>
+  <%= model.tableName %>: Schema.Schema.Type<typeof <%= model.typeName %>>;
+<% }) %>
+}

package/dist/src/templates/prisma-repository.eta

@@ -1,6 +1,3 @@
-/** biome-ignore-all lint/suspicious/noExplicitAny: <todo> */
-/** biome-ignore-all lint/style/useDefaultSwitchClause: <todo> */
-
 import * as VariantSchema from '@effect/experimental/VariantSchema'
 import { type PrismaClient as BasePrismaClient, Prisma as PrismaNamespace } from '<%= it.clientImportPath %>'
 import { PrismaClient } from './index.js'
@@ -9,6 +6,7 @@ import * as Effect from 'effect/Effect'
 import type * as Option from 'effect/Option'
 import * as Schema from 'effect/Schema'
 import * as SqlSchema from './prisma-schema.js'
+import { Insertable, Updateable } from '@effectify/prisma'
 
 export class PrismaUniqueConstraintError extends Data.TaggedError('PrismaUniqueConstraintError')<{
   cause: PrismaNamespace.PrismaClientKnownRequestError
@@ -142,7 +140,8 @@ export type PrismaUpdateManyError =
 // Create, Upsert
 export const mapCreateError = (error: unknown, operation: string, model: string): PrismaCreateError => {
   if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
+    const prismaError = error as PrismaNamespace.PrismaClientKnownRequestError;
+    switch (prismaError.code) {
       case 'P2000':
         return new PrismaValueTooLongError({ cause: error, operation, model })
       case 'P2002':
@@ -175,7 +174,8 @@ export const mapCreateError = (error: unknown, operation: string, model: string)
 // Update
 export const mapUpdateError = (error: unknown, operation: string, model: string): PrismaUpdateError => {
   if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
+    const prismaError = error as PrismaNamespace.PrismaClientKnownRequestError;
+    switch (prismaError.code) {
       case "P2000":
         return new PrismaValueTooLongError({ cause: error, operation, model });
       case "P2002":
@@ -212,7 +212,8 @@ export const mapUpdateError = (error: unknown, operation: string, model: string)
 // Delete
 export const mapDeleteError = (error: unknown, operation: string, model: string): PrismaDeleteError => {
   if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
+    const prismaError = error as PrismaNamespace.PrismaClientKnownRequestError;
+    switch (prismaError.code) {
       case "P2003":
         return new PrismaForeignKeyConstraintError({ cause: error, operation, model });
       case "P2014":
@@ -231,7 +232,8 @@ export const mapDeleteError = (error: unknown, operation: string, model: string)
 // FindOrThrow
 export const mapFindOrThrowError = (error: unknown, operation: string, model: string): PrismaFindOrThrowError => {
   if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
+    const prismaError = error as PrismaNamespace.PrismaClientKnownRequestError;
+    switch (prismaError.code) {
       case "P2024":
         return new PrismaConnectionError({ cause: error, operation, model });
       case "P2025":
@@ -244,7 +246,8 @@ export const mapFindOrThrowError = (error: unknown, operation: string, model: st
 // Find
 export const mapFindError = (error: unknown, operation: string, model: string): PrismaFindError => {
   if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
+    const prismaError = error as PrismaNamespace.PrismaClientKnownRequestError;
+    switch (prismaError.code) {
       case "P2024":
         return new PrismaConnectionError({ cause: error, operation, model });
     }
@@ -255,7 +258,8 @@ export const mapFindError = (error: unknown, operation: string, model: string):
 // DeleteMany
 export const mapDeleteManyError = (error: unknown, operation: string, model: string): PrismaDeleteManyError => {
   if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
+    const prismaError = error as PrismaNamespace.PrismaClientKnownRequestError;
+    switch (prismaError.code) {
       case "P2003":
         return new PrismaForeignKeyConstraintError({ cause: error, operation, model });
       case "P2014":
@@ -272,7 +276,8 @@ export const mapDeleteManyError = (error: unknown, operation: string, model: str
 // UpdateMany
 export const mapUpdateManyError = (error: unknown, operation: string, model: string): PrismaUpdateManyError => {
   if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
+    const prismaError = error as PrismaNamespace.PrismaClientKnownRequestError;
+    switch (prismaError.code) {
       case "P2000":
         return new PrismaValueTooLongError({ cause: error, operation, model });
       case "P2002":
@@ -357,6 +362,26 @@ export type AnyNoContext = Schema.Schema.AnyNoContext & {
   readonly jsonUpdate: Schema.Schema.AnyNoContext
 }
 
+/**
+ * Extract TypeScript types from model variants for compile-time validation
+ * @since 1.0.0
+ * @category types
+ */
+export type ModelTypes<S extends Any> = {
+  /** Type for create operations */
+  readonly Create: Schema.Schema.Type<S['create']>
+  /** Type for update operations */
+  readonly Update: Schema.Schema.Type<S['update']>
+  /** Type for base model */
+  readonly Model: Schema.Schema.Type<S>
+  /** Type for JSON API */
+  readonly Json: Schema.Schema.Type<S['json']>
+  /** Type for JSON create operations */
+  readonly JsonCreate: Schema.Schema.Type<S['jsonCreate']>
+  /** Type for JSON update operations */
+  readonly JsonUpdate: Schema.Schema.Type<S['jsonUpdate']>
+}
+
 /**
  * @since 1.0.0
  * @category models
@@ -501,23 +526,23 @@ export const make = <S extends Any, M extends keyof BasePrismaClient>(
     ) => Effect.Effect<Array<S['Type']>, PrismaFindError, S['Context'] | S['findMany']['Context']>
 
     readonly create: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'create'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'create'>>,
+      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'create'>> & { data: Insertable<S['Type']> },
     ) => Effect.Effect<S['Type'], PrismaCreateError, S['Context'] | S['create']['Context']>
 
     readonly createMany: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'createMany'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'createMany'>>,
+      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'createMany'>> & { data: ReadonlyArray<Insertable<S['Type']>> | Insertable<S['Type']> },
     ) => Effect.Effect<PrismaNamespace.BatchPayload, PrismaCreateError, S['Context'] | S['createMany']['Context']>
 
     readonly createManyAndReturn: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'createManyAndReturn'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'createManyAndReturn'>>,
+      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'createManyAndReturn'>> & { data: ReadonlyArray<Insertable<S['Type']>> | Insertable<S['Type']> },
     ) => Effect.Effect<Array<S['Type']>, PrismaCreateError, S['Context'] | S['createManyAndReturn']['Context']>
 
     readonly update: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'update'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'update'>>
+      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'update'>> & { data: Updateable<S['Type']> }
     ) => Effect.Effect<S['Type'], PrismaUpdateError, S['Context'] | S['update']['Context']>
 
     readonly updateMany: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'updateMany'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'updateMany'>>
+      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'updateMany'>> & { data: Updateable<S['Type']> }
     ) => Effect.Effect<PrismaNamespace.BatchPayload, PrismaUpdateManyError, S['Context'] | S['update']['Context']>
 
     readonly delete: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'delete'>>(
@@ -529,7 +554,7 @@ export const make = <S extends Any, M extends keyof BasePrismaClient>(
     ) => Effect.Effect<PrismaNamespace.BatchPayload, PrismaDeleteManyError, S['Context']>
 
     readonly upsert: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'upsert'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'upsert'>>
+      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'upsert'>> & { create: Insertable<S['Type']>; update: Updateable<S['Type']> }
     ) => Effect.Effect<S['Type'], PrismaCreateError, S['Context']>
 
     readonly count: <A extends PrismaNamespace.Args<BasePrismaClient[M], 'count'>>(
@@ -696,12 +721,12 @@ export const make = <S extends Any, M extends keyof BasePrismaClient>(
     })
 
     const create = <A extends PrismaNamespace.Args<BasePrismaClient[M], 'create'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'create'>>,
+      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'create'>> & { data: Insertable<S['Type']> },
     ): Effect.Effect<S['Type'], never, S['Context'] | S['create']['Context']> =>
       createSchema((args as any).data).pipe(
         Effect.catchTag('ParseError', Effect.die),
         Effect.catchTag('NoSuchElementException', Effect.die),
-        Effect.withSpan(`\${options.spanPrefix}.create`, {
+        Effect.withSpan(`${options.spanPrefix}.create`, {
           captureStackTrace: false,
           attributes: { ...(args as any).data },
         }),
@@ -719,13 +744,13 @@ export const make = <S extends Any, M extends keyof BasePrismaClient>(
     })
 
     const createMany = <A extends PrismaNamespace.Args<BasePrismaClient[M], 'createMany'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'createMany'>>,
+      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'createMany'>> & { data: ReadonlyArray<Insertable<S['Type']>> | Insertable<S['Type']> },
     ): Effect.Effect<PrismaNamespace.BatchPayload, never, S['Context'] | S['createMany']['Context']> =>
       createManySchema((args as any).data).pipe(
         Effect.map((res) => res as unknown as PrismaNamespace.BatchPayload),
         Effect.catchTag('ParseError', Effect.die),
         Effect.catchTag('NoSuchElementException', Effect.die),
-        Effect.withSpan(`\${options.spanPrefix}.createMany`, {
+        Effect.withSpan(`${options.spanPrefix}.createMany`, {
           captureStackTrace: false,
           attributes: { ...(args as any).data },
         }),
@@ -745,11 +770,11 @@ export const make = <S extends Any, M extends keyof BasePrismaClient>(
     })
 
     const createManyAndReturn = <A extends PrismaNamespace.Args<BasePrismaClient[M], 'createManyAndReturn'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'createManyAndReturn'>>,
+      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'createManyAndReturn'>> & { data: ReadonlyArray<Insertable<S['Type']>> | Insertable<S['Type']> },
     ): Effect.Effect<Array<S['Type']>, never, S['Context'] | S['createManyAndReturn']['Context']> =>
       createManyAndReturnSchema((args as any).data).pipe(
         Effect.catchTag('ParseError', Effect.die),
-        Effect.withSpan(`\${options.spanPrefix}.createManyAndReturn`, {
+        Effect.withSpan(`${options.spanPrefix}.createManyAndReturn`, {
           captureStackTrace: false,
           attributes: { ...(args as any).data },
         }),
@@ -788,12 +813,12 @@ export const make = <S extends Any, M extends keyof BasePrismaClient>(
     })
 
     const update = <A extends PrismaNamespace.Args<BasePrismaClient[M], 'update'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'update'>>
+      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'update'>> & { data: Updateable<S['Type']> }
     ): Effect.Effect<S['Type'], never, S['Context'] | S['update']['Context']> =>
       updateSchema(args).pipe(
         Effect.catchTag('ParseError', Effect.die),
         Effect.catchTag('NoSuchElementException', Effect.die),
-        Effect.withSpan(`\${options.spanPrefix}.update`, {
+        Effect.withSpan(`${options.spanPrefix}.update`, {
           captureStackTrace: false,
           attributes: { ...(args as any) },
         }),
@@ -815,7 +840,7 @@ export const make = <S extends Any, M extends keyof BasePrismaClient>(
       deleteSchema(args).pipe(
         Effect.catchTag('ParseError', Effect.die),
         Effect.catchTag('NoSuchElementException', Effect.die),
-        Effect.withSpan(`\${options.spanPrefix}.delete`, {
+        Effect.withSpan(`${options.spanPrefix}.delete`, {
           captureStackTrace: false,
           attributes: { ...(args as any) },
         }),
@@ -832,12 +857,12 @@ export const make = <S extends Any, M extends keyof BasePrismaClient>(
     })
 
     const upsert = <A extends PrismaNamespace.Args<BasePrismaClient[M], 'upsert'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'upsert'>>
+      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'upsert'>> & { create: Insertable<S['Type']>; update: Updateable<S['Type']> }
     ): Effect.Effect<S['Type'], never, S['Context']> =>
       upsertSchema(args).pipe(
         Effect.catchTag('ParseError', Effect.die),
         Effect.catchTag('NoSuchElementException', Effect.die),
-        Effect.withSpan(`\${options.spanPrefix}.upsert`, {
+        Effect.withSpan(`${options.spanPrefix}.upsert`, {
           captureStackTrace: false,
           attributes: { ...(args as any) },
         }),
@@ -859,7 +884,7 @@ export const make = <S extends Any, M extends keyof BasePrismaClient>(
       aggregateSchema(args).pipe(
         Effect.catchTag('ParseError', Effect.die),
         Effect.catchTag('NoSuchElementException', Effect.die),
-        Effect.withSpan(`\${options.spanPrefix}.aggregate`, {
+        Effect.withSpan(`${options.spanPrefix}.aggregate`, {
           captureStackTrace: false,
           attributes: { ...(args as any) },
         }),
@@ -880,7 +905,7 @@ export const make = <S extends Any, M extends keyof BasePrismaClient>(
     ): Effect.Effect<unknown, never, S['Context']> =>
       groupBySchema(args).pipe(
         Effect.catchTag('ParseError', Effect.die),
-        Effect.withSpan(`\${options.spanPrefix}.groupBy`, {
+        Effect.withSpan(`${options.spanPrefix}.groupBy`, {
           captureStackTrace: false,
           attributes: { ...(args as any) },
         }),
@@ -897,13 +922,13 @@ export const make = <S extends Any, M extends keyof BasePrismaClient>(
     })
 
     const updateMany = <A extends PrismaNamespace.Args<BasePrismaClient[M], 'updateMany'>>(
-      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'updateMany'>>
+      args: PrismaNamespace.Exact<A, PrismaNamespace.Args<BasePrismaClient[M], 'updateMany'>> & { data: Updateable<S['Type']> }
     ): Effect.Effect<PrismaNamespace.BatchPayload, never, S['Context'] | S['update']['Context']> =>
       updateManySchema(args).pipe(
         Effect.map((res) => res as unknown as PrismaNamespace.BatchPayload),
         Effect.catchTag('ParseError', Effect.die),
         Effect.catchTag('NoSuchElementException', Effect.die),
-        Effect.withSpan(`\${options.spanPrefix}.updateMany`, {
+        Effect.withSpan(`${options.spanPrefix}.updateMany`, {
           captureStackTrace: false,
           attributes: { ...(args as any) },
         }),
@@ -926,7 +951,7 @@ export const make = <S extends Any, M extends keyof BasePrismaClient>(
         Effect.map((res) => res as unknown as PrismaNamespace.BatchPayload),
         Effect.catchTag('ParseError', Effect.die),
         Effect.catchTag('NoSuchElementException', Effect.die),
-        Effect.withSpan(`\${options.spanPrefix}.deleteMany`, {
+        Effect.withSpan(`${options.spanPrefix}.deleteMany`, {
           captureStackTrace: false,
           attributes: { ...(args as any) },
         }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effectify/prisma",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "",
   "main": "./dist/src/cli.js",
   "type": "module",
@@ -9,8 +9,9 @@
     "effect-prisma": "./dist/src/cli.js"
   },
   "exports": {
-    ".": "./dist/src/cli.js",
-    "./prisma": "./dist/prisma/index.js"
+    ".": "./dist/src/runtime/index.js",
+    "./prisma": "./dist/prisma/index.js",
+    "./cli": "./dist/src/cli.js"
   },
   "files": [
     "dist"
@@ -21,6 +22,8 @@
   "keywords": [],
   "author": "",
   "dependencies": {
+    "@dprint/formatter": "^0.5.1",
+    "@dprint/typescript": "^0.95.15",
     "@effect/cli": "0.73.0",
     "@prisma/adapter-better-sqlite3": "7.3.0",
     "@prisma/generator": "7.3.0",
@@ -32,11 +35,10 @@
   "peerDependencies": {
     "@effect/platform": "0.94.0",
     "@effect/platform-node": "0.104.0",
-    "effect": "3.19.13",
-    "@prisma/client": "7.3.0"
+    "@prisma/client": "7.3.0",
+    "effect": "3.19.15"
   },
   "devDependencies": {
-    "prisma-effect-kysely": "5.2.0",
     "@effect/build-utils": "0.8.9",
     "@effect/experimental": "0.58.0",
     "@effect/language-service": "0.56.0",
@@ -45,6 +47,8 @@
     "@types/better-sqlite3": "7.6.13",
     "@types/node": "20.19.25",
     "bun": "1.3.0",
+    "dprint": "0.51.1",
+    "oxlint": "0.15.15",
     "prisma": "7.3.0",
     "tsx": "4.20.6",
     "typescript": "5.9.3",
@@ -53,6 +57,7 @@
   },
   "scripts": {
     "prisma:generate": "pnpm dlx prisma generate",
+    "build": "effect-build",
     "test": "vitest",
     "dev": "tsx src/messaround.ts",
     "cli": "pnpm dlx tsx src/cli.ts"