@effectify/prisma 0.1.2 → 1.0.1

package/dist/src/cli.d.ts

@@ -1,2 +1,2 @@
-#!/usr/bin/env bun
+#!/usr/bin/env -S pnpm dlx tsx
 export {};

package/dist/src/cli.js

@@ -1,17 +1,17 @@
-#!/usr/bin/env bun
+#!/usr/bin/env -S pnpm dlx tsx
 import * as Command from '@effect/cli/Command';
 import * as NodeContext from '@effect/platform-node/NodeContext';
 import * as NodeRuntime from '@effect/platform-node/NodeRuntime';
-import * as Console from 'effect/Console';
 import * as Effect from 'effect/Effect';
-import { generateEffectCommand } from './commands/generate-effect.js';
-import { generateSqlSchemaCommand } from './commands/generate-sql-schema.js';
+import * as Layer from 'effect/Layer';
 import { initCommand } from './commands/init.js';
-// Main CLI command
-const prisma = Command.make('prisma', {}, () => Console.log('🚀 prisma CLI - Use --help to see available commands')).pipe(Command.withSubcommands([initCommand, generateEffectCommand, generateSqlSchemaCommand]));
-// Run the CLI
-const cli = Command.run(prisma, {
+import { prismaCommand } from './commands/prisma.js';
+import { GeneratorService } from './services/generator-service.js';
+import { RenderService } from './services/render-service.js';
+const cli = Command.run(prismaCommand.pipe(Command.withSubcommands([initCommand])), {
     name: '@effectify/prisma CLI',
     version: '0.1.0',
 });
-cli(process.argv).pipe(Effect.provide(NodeContext.layer), NodeRuntime.runMain);
+const GeneratorLayer = GeneratorService.Live.pipe(Layer.provide(RenderService.Live), Layer.provide(NodeContext.layer));
+const MainLayer = Layer.mergeAll(GeneratorLayer, RenderService.Live, NodeContext.layer);
+cli(process.argv).pipe(Effect.provide(MainLayer), NodeRuntime.runMain);

package/dist/src/commands/init.d.ts

@@ -1,4 +1,4 @@
 import * as Command from '@effect/cli/Command';
-export declare const initCommand: Command.Command<"init", never, Error | import("@effect/platform/Error").PlatformError, {
+export declare const initCommand: Command.Command<"init", never, import("@effect/platform/Error").PlatformError | Error, {
     readonly output: string;
 }>;

package/dist/src/commands/init.js

@@ -91,10 +91,8 @@ generator sqlSchema {
     yield* Console.log('   1. Set your DATABASE_URL environment variable');
     yield* Console.log('   2. Run: @effectify/prisma prisma generate-effect');
     yield* Console.log('   3. Run: @effectify/prisma prisma generate-sql-schema');
-    // Ensure the effect completes and exits
     yield* Effect.sync(() => process.exit(0));
 });
-// Export the init command
 export const initCommand = Command.make('init', {
     output: outputOption,
 }, ({ output }) => initializePrismaSchema({

package/dist/src/commands/prisma.d.ts

@@ -0,0 +1,5 @@
+import * as Command from '@effect/cli/Command';
+import type * as NodeContext from '@effect/platform-node/NodeContext';
+import { GeneratorService } from '../services/generator-service.js';
+import type { RenderService } from '../services/render-service.js';
+export declare const prismaCommand: Command.Command<"prisma", RenderService | GeneratorService | NodeContext.NodeContext, never, {}>;

package/dist/src/commands/prisma.js

@@ -0,0 +1,35 @@
+import * as Command from '@effect/cli/Command';
+import generatorHelper from '@prisma/generator-helper';
+import * as Deferred from 'effect/Deferred';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Runtime from 'effect/Runtime';
+import * as Stream from 'effect/Stream';
+import { GeneratorContext } from '../services/generator-context.js';
+import { GeneratorService } from '../services/generator-service.js';
+export const prismaCommand = Command.make('prisma', {}, () => Effect.gen(function* () {
+    const generator = yield* GeneratorService;
+    const runtime = yield* Effect.runtime();
+    const run = Runtime.runPromise(runtime);
+    const events = Stream.async((emit) => {
+        generatorHelper.generatorHandler({
+            onManifest() {
+                return {
+                    defaultOutput: '../generated/effect',
+                    prettyName: 'Prisma Effect Generator',
+                    requiresEngines: [],
+                };
+            },
+            async onGenerate(options) {
+                await run(Effect.gen(function* () {
+                    const deferred = yield* Deferred.make();
+                    yield* Effect.promise(() => emit.single([options, deferred]));
+                    yield* Deferred.await(deferred);
+                }));
+                // Cerrar el stream después de procesar la generación
+                emit.end();
+            },
+        });
+    });
+    yield* events.pipe(Stream.runForEach(([options, deferred]) => generator.generate.pipe(Effect.provide(Layer.succeed(GeneratorContext, options)), Effect.intoDeferred(deferred))));
+}));

package/dist/src/generators/sql-schema-generator.d.ts

@@ -1 +1,10 @@
+#!/usr/bin/env tsx
+type SqlGeneratorOptions = {
+    generator: {
+        output?: {
+            value: string;
+        };
+    };
+};
+export declare function generateSqlSchema(options: SqlGeneratorOptions): Promise<void>;
 export {};

package/dist/src/generators/sql-schema-generator.js

@@ -1,58 +1,50 @@
-// #!/usr/bin/env tsx
-export {};
-// import { execSync } from 'node:child_process'
-// import fs from 'node:fs/promises'
-// import path from 'node:path'
-// import gh from '@prisma/generator-helper'
-// const header = `-- This file was generated by sql-schema-generator, do not edit manually.
-// -- Generated at: ${new Date().toISOString()}
-// `
-// // Types for generator options
-// interface SqlGeneratorOptions {
-//   generator: {
-//     output?: {
-//       value: string
-//     }
-//   }
-// }
-// // Export the generator function for use in CLI
-// export async function generateSqlSchema(options: SqlGeneratorOptions) {
-//   const outputDir = options.generator.output?.value || '../generated'
-//   const datasourceUrl = 'prisma/dev.db'
-//   if (!datasourceUrl) {
-//     throw new Error('No datasource URL found')
-//   }
-//   // Ensure output directory exists
-//   await fs.mkdir(outputDir, { recursive: true })
-//   try {
-//     // Extract the database path from the URL (assuming sqlite)
-//     let dbPath = datasourceUrl
-//     if (dbPath.startsWith('file:')) {
-//       dbPath = dbPath.replace('file:', '')
-//     }
-//     // Make path relative to current working directory if needed
-//     if (!path.isAbsolute(dbPath)) {
-//       dbPath = path.resolve(process.cwd(), dbPath)
-//     }
-//     // Use sqlite3 to dump only the schema (no data)
-//     const schemaOutput = execSync(`sqlite3 "${dbPath}" ".schema"`, { encoding: 'utf8' })
-//     // Write the schema to the output file
-//     const outputPath = path.join(outputDir, 'schema.sql')
-//     await fs.writeFile(outputPath, header + schemaOutput)
-//   } catch (error) {
-//     console.error('❌ Failed to generate schema dump:', error.message)
-//     throw error
-//   }
-// }
-// gh.generatorHandler({
-//   onManifest() {
-//     return {
-//       defaultOutput: '../generated',
-//       prettyName: 'SQL Schema Generator',
-//       requiresEngines: [],
-//     }
-//   },
-//   async onGenerate(options) {
-//     await generateSqlSchema(options)
-//   },
-// })
+#!/usr/bin/env tsx
+// biome-ignore-all lint: Generated code
+import { execSync } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import gh from '@prisma/generator-helper';
+const header = `-- This file was generated by sql-schema-generator, do not edit manually.
+-- Generated at: ${new Date().toISOString()}
+
+`;
+export async function generateSqlSchema(options) {
+    const outputDir = options.generator.output?.value || '../generated';
+    const datasourceUrl = 'prisma/dev.db';
+    if (!datasourceUrl) {
+        throw new Error('No datasource URL found');
+    }
+    await fs.mkdir(outputDir, { recursive: true });
+    try {
+        let dbPath = datasourceUrl;
+        if (dbPath.startsWith('file:')) {
+            dbPath = dbPath.replace('file:', '');
+        }
+        if (!path.isAbsolute(dbPath)) {
+            dbPath = path.resolve(process.cwd(), dbPath);
+        }
+        const schemaOutput = execSync(`sqlite3 "${dbPath}" ".schema"`, { encoding: 'utf8' });
+        const outputPath = path.join(outputDir, 'schema.sql');
+        await fs.writeFile(outputPath, header + schemaOutput);
+    }
+    catch (error) {
+        console.error('❌ Failed to generate schema dump:', error);
+        throw error;
+    }
+}
+gh.generatorHandler({
+    onManifest() {
+        return {
+            defaultOutput: '../generated',
+            prettyName: 'SQL Schema Generator',
+            requiresEngines: [],
+        };
+    },
+    async onGenerate(options) {
+        await generateSqlSchema({
+            generator: {
+                output: options?.generator?.output ? { value: options.generator.output.value || '' } : undefined,
+            },
+        });
+    },
+});

package/dist/src/services/generator-context.d.ts

@@ -0,0 +1,6 @@
+import type { GeneratorOptions } from '@prisma/generator-helper';
+import * as Context from 'effect/Context';
+declare const GeneratorContext_base: Context.TagClass<GeneratorContext, "GeneratorContext", GeneratorOptions>;
+export declare class GeneratorContext extends GeneratorContext_base {
+}
+export {};

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

@@ -0,0 +1,3 @@
+import * as Context from 'effect/Context';
+export class GeneratorContext extends Context.Tag('GeneratorContext')() {
+}

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

@@ -0,0 +1,14 @@
+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';
+declare const GeneratorService_base: Context.TagClass<GeneratorService, "GeneratorService", {
+    readonly generate: Effect.Effect<void, Error, GeneratorContext>;
+}>;
+export declare class GeneratorService extends GeneratorService_base {
+    static Live: Layer.Layer<GeneratorService, never, FileSystem.FileSystem | Path.Path | RenderService>;
+}
+export {};

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

@@ -0,0 +1,121 @@
+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')() {
+    static Live = Layer.effect(GeneratorService, Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const { render } = yield* RenderService;
+        const parseErrorImportPath = (errorImportPath) => {
+            if (!errorImportPath) {
+                return null;
+            }
+            const [modulePath, className] = errorImportPath.split('#');
+            if (!(modulePath && className)) {
+                throw new Error(`Invalid errorImportPath format: "${errorImportPath}". Expected "path/to/module#ErrorClassName"`);
+            }
+            return { path: modulePath, className };
+        };
+        const addExtension = (filePath, extension) => {
+            if (!extension) {
+                return filePath;
+            }
+            const ext = path.extname(filePath);
+            if (ext) {
+                return filePath;
+            }
+            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');
+        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 getCustomError = (config, options, schemaDir) => {
+            const errorImportPathRaw = getErrorImportPath(config);
+            const importFileExtension = getImportFileExtension(config);
+            let customError = parseErrorImportPath(errorImportPathRaw);
+            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 pathWithExtension = addExtension(normalizedPath, importFileExtension);
+                    customError = { ...customError, path: pathWithExtension };
+                }
+            }
+            return customError;
+        };
+        const getGeneratorConfig = (options, schemaDir) => {
+            const { config } = options.generator;
+            const clientImportPath = getClientImportPath(config);
+            const customError = getCustomError(config, options, schemaDir);
+            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 generatePrismaRepository = (outputDir, clientImportPath) => Effect.gen(function* () {
+            const content = yield* render('prisma-repository', { clientImportPath });
+            yield* fs.writeFileString(path.join(outputDir, 'prisma-repository.ts'), content);
+        });
+        const generateModels = (outputDir, models) => Effect.gen(function* () {
+            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 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 content = yield* render(templateName, {
+                clientImportPath,
+                customError,
+                rawSqlOperations,
+                modelExports,
+            });
+            yield* fs.writeFileString(path.join(outputDir, 'index.ts'), content);
+        });
+        const generate = Effect.gen(function* () {
+            const options = yield* GeneratorContext;
+            const models = options.dmmf.datamodel.models;
+            const outputDir = options.generator.output?.value;
+            const schemaDir = path.dirname(options.schemaPath);
+            if (!outputDir) {
+                return yield* Effect.fail(new Error('No output directory specified'));
+            }
+            const { clientImportPath, customError } = getGeneratorConfig(options, schemaDir);
+            yield* fs.makeDirectory(outputDir, { recursive: true });
+            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

@@ -0,0 +1,10 @@
+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>;
+}>;
+export declare class RenderService extends RenderService_base {
+    static Live: Layer.Layer<RenderService, never, never>;
+}
+export {};

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

@@ -0,0 +1,23 @@
+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')() {
+    static Live = Layer.sync(RenderService, () => {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+        const templatesDir = path.resolve(__dirname, '../templates');
+        const eta = new Eta({
+            views: templatesDir,
+            autoEscape: false,
+        });
+        return {
+            render: (templateName, data) => Effect.try({
+                try: () => eta.render(templateName, data),
+                catch: (error) => new Error(`Failed to render template ${templateName}: ${error}`),
+            }),
+        };
+    });
+}

package/{src → dist/src}/templates/index-default.eta

@@ -201,7 +201,7 @@ 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.code) {
+    switch (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
       case "P2000":
         return new PrismaValueTooLongError({ cause: error, operation, model });
       case "P2002":

package/dist/src/templates/model.eta

@@ -0,0 +1,8 @@
+import * as Model from "../prisma-repository.js"
+import { <%= it.model.name %>, <%= it.model.name %>Id } from "../schemas/index.js"
+
+export class <%= it.model.name %>Model extends Model.Class<<%= it.model.name %>Model>("<%= it.model.name %>")({
+  ...<%= it.model.name %>.fields
+}) {}
+
+export { <%= it.model.name %>, <%= it.model.name %>Id }

package/{src → dist/src}/templates/prisma-repository.eta

@@ -142,7 +142,7 @@ export type PrismaUpdateManyError =
 // Create, Upsert
 export const mapCreateError = (error: unknown, operation: string, model: string): PrismaCreateError => {
   if (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
-    switch (error.code) {
+    switch (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
       case 'P2000':
         return new PrismaValueTooLongError({ cause: error, operation, model })
       case 'P2002':
@@ -175,7 +175,7 @@ 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.code) {
+    switch (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
       case "P2000":
         return new PrismaValueTooLongError({ cause: error, operation, model });
       case "P2002":
@@ -212,7 +212,7 @@ 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.code) {
+    switch (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
       case "P2003":
         return new PrismaForeignKeyConstraintError({ cause: error, operation, model });
       case "P2014":
@@ -231,7 +231,7 @@ 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.code) {
+    switch (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
       case "P2024":
         return new PrismaConnectionError({ cause: error, operation, model });
       case "P2025":
@@ -244,7 +244,7 @@ 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.code) {
+    switch (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
       case "P2024":
         return new PrismaConnectionError({ cause: error, operation, model });
     }
@@ -255,7 +255,7 @@ 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.code) {
+    switch (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
       case "P2003":
         return new PrismaForeignKeyConstraintError({ cause: error, operation, model });
       case "P2014":
@@ -272,7 +272,7 @@ 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.code) {
+    switch (error instanceof PrismaNamespace.PrismaClientKnownRequestError) {
       case "P2000":
         return new PrismaValueTooLongError({ cause: error, operation, model });
       case "P2002":

package/package.json

@@ -1,16 +1,20 @@
 {
   "name": "@effectify/prisma",
-  "version": "0.1.2",
+  "version": "1.0.1",
   "description": "",
-  "main": "index.js",
+  "main": "./dist/src/cli.js",
   "type": "module",
   "license": "MIT",
   "bin": {
-    "effect-prisma": "./src/cli.ts"
+    "effect-prisma": "./dist/src/cli.js"
   },
   "exports": {
-    "./prisma": "./prisma/index.ts"
+    ".": "./dist/src/cli.js",
+    "./prisma": "./dist/prisma/index.js"
   },
+  "files": [
+    "dist"
+  ],
   "publishConfig": {
     "access": "public"
   },
@@ -18,9 +22,9 @@
   "author": "",
   "dependencies": {
     "@effect/cli": "0.73.0",
-    "@prisma/adapter-better-sqlite3": "7.0.0",
-    "@prisma/generator": "^7.0.1",
-    "@prisma/generator-helper": "7.0.0",
+    "@prisma/adapter-better-sqlite3": "7.3.0",
+    "@prisma/generator": "7.3.0",
+    "@prisma/generator-helper": "7.3.0",
     "better-sqlite3": "12.4.6",
     "eta": "^4.5.0",
     "kysely": "0.28.8"
@@ -29,19 +33,19 @@
     "@effect/platform": "0.94.0",
     "@effect/platform-node": "0.104.0",
     "effect": "3.19.13",
-    "@prisma/client": "7.0.0"
+    "@prisma/client": "7.3.0"
   },
   "devDependencies": {
-    "prisma-effect-kysely": "1.13.1",
+    "prisma-effect-kysely": "5.2.0",
     "@effect/build-utils": "0.8.9",
     "@effect/experimental": "0.58.0",
     "@effect/language-service": "0.56.0",
     "@effect/vitest": "0.27.0",
-    "@prisma/internals": "7.0.0",
+    "@prisma/internals": "7.3.0",
     "@types/better-sqlite3": "7.6.13",
     "@types/node": "20.19.25",
     "bun": "1.3.0",
-    "prisma": "7.0.0",
+    "prisma": "7.3.0",
     "tsx": "4.20.6",
     "typescript": "5.9.3",
     "vite-tsconfig-paths": "5.1.4",

package/dist/src/commands/generate-effect.d.ts

@@ -1,2 +0,0 @@
-import * as Command from '@effect/cli/Command';
-export declare const generateEffectCommand: Command.Command<"generate-effect", never, Error | import("@effect/platform/Error").PlatformError, {}>;

package/dist/src/commands/generate-effect.js

@@ -1,73 +0,0 @@
-import * as Command from '@effect/cli/Command';
-import * as FileSystem from '@effect/platform/FileSystem';
-import * as NodeFileSystem from '@effect/platform-node/NodeFileSystem';
-import * as NodePath from '@effect/platform-node/NodePath';
-import * as Console from 'effect/Console';
-import * as Effect from 'effect/Effect';
-import * as Match from 'effect/Match';
-// import { generateEffectPrisma } from '../generators/prisma-effect-generator.js'
-// Check if file exists
-const fileExists = (path) => Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
-    return yield* fs.exists(path);
-});
-// Detect package manager using pattern matching
-const detectPackageManager = () => Effect.gen(function* () {
-    const pnpmExists = yield* fileExists('pnpm-lock.yaml');
-    const bunExists = yield* fileExists('bun.lockb');
-    const npmExists = yield* fileExists('package-lock.json');
-    // Create a tuple to match against
-    const lockFiles = [pnpmExists, bunExists, npmExists];
-    return Match.value(lockFiles).pipe(Match.when([true, false, false], () => 'pnpm'), Match.when([false, true, false], () => 'bun'), Match.when([false, false, true], () => 'npm'), Match.orElse(() => 'npm'));
-});
-// Check if Prisma schema exists
-const checkPrismaSchema = () => Effect.gen(function* () {
-    const schemaExists = yield* fileExists('prisma/schema.prisma');
-    if (!schemaExists) {
-        yield* Console.log('❌ Prisma schema not found.');
-        yield* Console.log('');
-        yield* Console.log('Please run the following command first:');
-        const packageManager = yield* detectPackageManager();
-        const initCommand = Match.value(packageManager).pipe(Match.when('pnpm', () => 'pnpm dlx prisma init'), Match.when('bun', () => 'bunx prisma init'), Match.when('npm', () => 'npx prisma init'), Match.exhaustive);
-        yield* Console.log(`  ${initCommand}`);
-        yield* Effect.fail(new Error('Prisma schema not found'));
-    }
-});
-// Execute the Effect generator
-const generateEffectServices = () => Effect.gen(function* () {
-    // Check if we're being called by Prisma (no interactive output)
-    const isCalledByPrisma = process.env.PRISMA_GENERATOR_INVOCATION === 'true' ||
-        process.argv.includes('--generator') ||
-        !process.stdout.isTTY;
-    if (!isCalledByPrisma) {
-        yield* Console.log('🔧 Running Effect generator...');
-    }
-    // Check if Prisma schema exists
-    yield* checkPrismaSchema();
-    // Note: We don't need to check for local generator files
-    // since we're importing from our own package
-    if (!isCalledByPrisma) {
-        yield* Console.log('🚀 Executing Effect generator...');
-    }
-    // Execute the generator function
-    yield* Effect.tryPromise({
-        try: () => {
-            // Create mock options for the generator
-            // const mockOptions = {
-            //   dmmf: { datamodel: { models: [] } }, // Empty models for now
-            //   generator: { output: { value: 'src/generated/effect-prisma' } },
-            // }
-            return Promise.resolve();
-            // return generateEffectPrisma(mockOptions)
-        },
-        catch: (error) => new Error(`Generator execution failed: ${error}`),
-    });
-    if (!isCalledByPrisma) {
-        yield* Console.log('✅ Effect generator executed successfully!');
-        yield* Console.log('💡 Generated files are available in the configured output directory');
-    }
-    // Ensure the effect completes and exits
-    yield* Effect.sync(() => process.exit(0));
-});
-// Export the generate-effect command
-export const generateEffectCommand = Command.make('generate-effect', {}, () => generateEffectServices().pipe(Effect.provide(NodeFileSystem.layer), Effect.provide(NodePath.layer)));

package/dist/src/commands/generate-sql-schema.d.ts

@@ -1,2 +0,0 @@
-import * as Command from '@effect/cli/Command';
-export declare const generateSqlSchemaCommand: Command.Command<"generate-sql-schema", never, Error | import("@effect/platform/Error").PlatformError, {}>;