effect-sql-kysely/src/internal/makeSchema.ts

A full-featured integration between `@effect/sql` and `Kysely` that provides type-safe database operations with Effect's powerful error handling and resource management.

import type * as kysely from "kysely";
import type * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as Sql from "@effect/sql";
import type { ParseResult, Schema } from "effect";
import type * as Option from "effect/Option";
import type { Types } from "effect";
import type { KyselyDatabase } from "../Database.js";
import type * as Cause from "effect/Cause";

export function makeSchema<ID, DB>(Tag: Context.Tag<ID, KyselyDatabase<DB>>) {
  const findAll =
    <IA, II, IR, A, AI, AR>(
      options: {
        readonly Request: Schema.Schema<IA, II, IR>
        readonly Result: Schema.Schema<A, AI, AR>
        readonly execute: (db: kysely.Kysely<DB>, request: II) => kysely.Compilable<AI>
      }
    ) =>
      (
        request: IA
      ) =>
        Effect.flatMap(Tag, ({ kysely }) =>
          Sql.SqlSchema.findAll({
            Request: options.Request,
            Result: options.Result,
            execute: (req) => kysely((db) => options.execute(db, req)),
          })(request)
        );

  const select =
    <IR, II, IA, A, AI extends object, AR>(options: {
      readonly Request: Schema.Schema<IA, II, IR>;
      readonly Result: Schema.Schema<A, AI, AR>;
      readonly execute: (
        db: kysely.Kysely<DB>,
        request: II
      ) => kysely.Compilable<Types.NoInfer<AI>>;
    }) =>
      (
        request: IA
      ): Effect.Effect<
        ReadonlyArray<A>,
        ParseResult.ParseError | Sql.SqlError.SqlError,
        IR | AR | ID
      > =>
        Effect.flatMap(Tag, ({ kysely }) =>
          Sql.SqlSchema.findAll({
            ...options,
            execute: (req) => kysely((db) => options.execute(db, req)),
          })(request)
        );

  const findOne =
    <IR, II, IA, AR, AI extends object, A>(options: {
      readonly Request: Schema.Schema<IA, II, IR>;
      readonly Result: Schema.Schema<A, AI, AR>;
      execute: (db: kysely.Kysely<DB>, request: II) => kysely.Compilable<AI>;
    }) =>
      (
        request: IA
      ): Effect.Effect<
        Option.Option<A>,
        ParseResult.ParseError | Sql.SqlError.SqlError,
        IR | AR | ID
      > =>
        Effect.flatMap(Tag, ({ kysely }) =>
          Sql.SqlSchema.findOne({
            ...options,
            execute: (req) => kysely((db) => options.execute(db, req)),
          })(request)
        );

  const single =
    <IR, II, IA, AR, AI extends object, A>(options: {
      readonly Request: Schema.Schema<IA, II, IR>;
      readonly Result: Schema.Schema<A, AI, AR>;
      readonly execute: (
        db: kysely.Kysely<DB>,
        request: II
      ) => kysely.Compilable<AI>;
    }) =>
      (
        request: IA
      ): Effect.Effect<
        A,
        | ParseResult.ParseError
        | Cause.NoSuchElementException
        | Sql.SqlError.SqlError,
        IR | AR | ID
      > =>
        Effect.flatMap(Tag, ({ kysely }) =>
          Sql.SqlSchema.single({
            ...options,
            execute: (req) => kysely((db) => options.execute(db, req)),
          })(request)
        );

  const void_ =
    <IR, II, IA>(options: {
      readonly Request: Schema.Schema<IA, II, IR>;
      readonly execute: (
        request: II,
        db: kysely.Kysely<DB>
      ) => kysely.Compilable<object>;
    }) =>
      (
        request: IA
      ): Effect.Effect<
        void,
        ParseResult.ParseError | Sql.SqlError.SqlError,
        IR | ID
      > =>
        Effect.flatMap(Tag, ({ kysely }) =>
          Sql.SqlSchema.void({
            ...options,
            execute: (req) => kysely((db) => options.execute(req, db)),
          })(request)
        );

  return {
    findAll,
    select,
    findOne,
    single,
    void: void_,
  } as const;
}