@effectify/prisma 0.1.1 → 0.1.2

package/src/templates/prisma-schema.eta

@@ -0,0 +1,94 @@
+/**
+ * @since 1.0.0
+ */
+import * as Cause from 'effect/Cause'
+import * as Effect from 'effect/Effect'
+import type * as Option from 'effect/Option'
+import type { ParseError } from 'effect/ParseResult'
+import * as Schema from 'effect/Schema'
+
+/**
+ * Run a sql query with a request schema and a result schema.
+ *
+ * @since 1.0.0
+ * @category constructor
+ */
+export const findAll = <IR, II, IA, AR, AI, A, R, E>(options: {
+  readonly Request: Schema.Schema<IA, II, IR>
+  readonly Result: Schema.Schema<A, AI, AR>
+  readonly execute: (request: II) => Effect.Effect<ReadonlyArray<unknown>, E, R>
+}) => {
+  const encodeRequest = Schema.encode(options.Request)
+  const decode = Schema.decodeUnknown(Schema.Array(options.Result))
+  return (request: IA): Effect.Effect<ReadonlyArray<A>, E | ParseError, R | IR | AR> =>
+    Effect.flatMap(Effect.flatMap(encodeRequest(request), options.execute), decode)
+}
+
+const void_ = <IR, II, IA, R, E>(options: {
+  readonly Request: Schema.Schema<IA, II, IR>
+  readonly execute: (request: II) => Effect.Effect<unknown, E, R>
+}) => {
+  const encode = Schema.encode(options.Request)
+  return (request: IA): Effect.Effect<void, E | ParseError, R | IR> =>
+    Effect.asVoid(Effect.flatMap(encode(request), options.execute))
+}
+export {
+  /**
+   * Run a sql query with a request schema and discard the result.
+   *
+   * @since 1.0.0
+   * @category constructor
+   */
+  void_ as void,
+}
+
+/**
+ * Run a sql query with a request schema and a result schema and return the first result.
+ *
+ * @since 1.0.0
+ * @category constructor
+ */
+export const findOne = <IR, II, IA, AR, AI, A, R, E>(options: {
+  readonly Request: Schema.Schema<IA, II, IR>
+  readonly Result: Schema.Schema<A, AI, AR>
+  readonly execute: (request: II) => Effect.Effect<ReadonlyArray<unknown>, E, R>
+}) => {
+  const encodeRequest = Schema.encode(options.Request)
+  const decode = Schema.decodeUnknown(options.Result)
+  return (request: IA): Effect.Effect<Option.Option<A>, E | ParseError, R | IR | AR> =>
+    Effect.flatMap(Effect.flatMap(encodeRequest(request), options.execute), (arr) =>
+      Array.isArray(arr) && arr.length > 0 ? Effect.asSome(decode(arr[0])) : Effect.succeedNone,
+    )
+}
+
+/**
+ * Run a sql query with a request schema and a result schema and return the first result.
+ *
+ * @since 1.0.0
+ * @category constructor
+ */
+export const single = <IR, II, IA, AR, AI, A, R, E>(options: {
+  readonly Request: Schema.Schema<IA, II, IR>
+  readonly Result: Schema.Schema<A, AI, AR>
+  readonly execute: (request: II) => Effect.Effect<ReadonlyArray<unknown>, E, R>
+}) => {
+  const encodeRequest = Schema.encode(options.Request)
+  const decode = Schema.decodeUnknown(options.Result)
+  return (request: IA): Effect.Effect<A, E | ParseError | Cause.NoSuchElementException, R | IR | AR> =>
+    Effect.flatMap(
+      Effect.flatMap(encodeRequest(request), options.execute),
+      (arr): Effect.Effect<A, ParseError | Cause.NoSuchElementException, AR> =>
+        Array.isArray(arr) && arr.length > 0 ? decode(arr[0]) : Effect.fail(new Cause.NoSuchElementException()),
+    )
+}
+
+export const many = <IR, II, IA, AR, AI, A, R, E>(options: {
+  readonly Request: Schema.Schema<IA, II, IR>
+  readonly Result: Schema.Schema<A, AI, AR>
+  readonly execute: (request: II) => Effect.Effect<Array<unknown>, E, R>
+}) => {
+  const encodeRequest = Schema.encode(options.Request)
+  const decode = Schema.decodeUnknown(Schema.Array(options.Result))
+  return (request: IA): Effect.Effect<Array<A>, E | ParseError, R | IR | AR> =>
+    Effect.map(Effect.flatMap(Effect.flatMap(encodeRequest(request), options.execute), decode), (arr) => [...arr])
+}

package/vitest.config.ts

@@ -7,6 +7,7 @@ export default defineConfig({
   test: {
     setupFiles: [path.join(__dirname, 'setup-tests.ts')],
     include: ['**/*.test.ts'],
+    exclude: ['**/node_modules/**', '**/dist/**', 'inspiration/**'],
     globals: true,
   },
   resolve: {

package/src/cli.tsx

@@ -1,23 +0,0 @@
-#!/usr/bin/env bun
-
-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 { 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, {
-  name: '@effectify/prisma CLI',
-  version: '0.1.0',
-})
-
-cli(process.argv).pipe(Effect.provide(NodeContext.layer), NodeRuntime.runMain)

package/src/commands/generate-effect.ts

@@ -1,109 +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: string) =>
-  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] as const
-
-    return Match.value(lockFiles).pipe(
-      Match.when([true, false, false], () => 'pnpm' as const),
-      Match.when([false, true, false], () => 'bun' as const),
-      Match.when([false, false, true], () => 'npm' as const),
-      Match.orElse(() => 'npm' as const), // default fallback
-    )
-  })
-
-// 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/src/commands/generate-sql-schema.ts

@@ -1,109 +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 { generateSqlSchema } from '../generators/sql-schema-generator.js'
-
-// Check if file exists
-const fileExists = (path: string) =>
-  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] as const
-
-    return Match.value(lockFiles).pipe(
-      Match.when([true, false, false], () => 'pnpm' as const),
-      Match.when([false, true, false], () => 'bun' as const),
-      Match.when([false, false, true], () => 'npm' as const),
-      Match.orElse(() => 'npm' as const), // default fallback
-    )
-  })
-
-// 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 SQL schema generator
-const generateSqlSchemaServices = () =>
-  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 SQL schema 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 SQL schema generator...')
-    }
-
-    // Execute the generator function
-    yield* Effect.tryPromise({
-      try: () => {
-        // Create mock options for the generator
-        // const mockOptions = {
-        //   generator: { output: { value: 'src/generated' } },
-        // }
-
-        // return generateSqlSchema(mockOptions)
-        return Promise.resolve()
-      },
-      catch: (error) => new Error(`Generator execution failed: ${error}`),
-    })
-
-    if (!isCalledByPrisma) {
-      yield* Console.log('✅ SQL schema 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-sql-schema command
-export const generateSqlSchemaCommand = Command.make('generate-sql-schema', {}, () =>
-  generateSqlSchemaServices().pipe(Effect.provide(NodeFileSystem.layer), Effect.provide(NodePath.layer)),
-)