@shivaedev/effect-prisma 0.7.1 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 0.9.0 - 2026-10-13
+
+### Changed
+
+- Use `T`-prefixed descriptive type parameter names in Relation types and internal testing and transaction helpers, preserving their type behavior.
+- Document the package purpose, query and transaction model, API and limits; add agent guidance and package north star and roadmap, and publish `docs/` with the README.
+- Build package JavaScript, declarations and source maps with TypeScript 7.
+
+### Breaking
+
+- Requires stable Effect 4.0.4 in place of 4.0.0-rc.112. Effect 4.0.4 moves the former `effect/unstable/*` modules to `effect/*` and renames constructors such as `Config.string` to `Config.String`. Install `@effect/vitest` 4.0.4 alongside it, which requires Vitest 5.
+
+## 0.8.0 - 2026-10-04
+
+### Changed
+
+- Breaking: no root entry and no module that re-exports another. `exports` maps one `"./*.ts"` pattern to every module outside `internal/` (`src` under the `source` condition, `dist` otherwise), and `"./internal/*": null` keeps `internal/` modules private, so you import the module that defines a name, and a bundler sees only the modules you use. Where each name now lives:
+  - `@shivaedev/effect-prisma`: `@prisma-next/sql-orm-client` (`all`, `and`, `not`, `or`), `@shivaedev/effect-prisma/databaseTypes.ts` (`AnyDatabase`, `DatabaseService`, `DatabaseServiceOf`), `@shivaedev/effect-prisma/database.ts` (`DatabaseDefinition`, `DatabaseLayerOptions`, `makeDatabase`), `@shivaedev/effect-prisma/error.ts` (`PrismaConnectionFailure`, `PrismaError`, `PrismaErrorReason`, `PrismaQueryFailure`, `PrismaRuntimeFailure`), `@shivaedev/effect-prisma/relation.ts` (`Relation`)
+  - `@shivaedev/effect-prisma/testing`: `@shivaedev/effect-prisma/testing/transaction.ts` (`withTestTransaction`), `@shivaedev/effect-prisma/databaseTypes.ts` (`AnyDatabase`), `@shivaedev/effect-prisma/testing/types.ts` (`DatabaseIt`, `DatabaseService`, `DatabaseTest`, `DatabaseTester`, `MakeDatabaseItOptions`), `@shivaedev/effect-prisma/testing/vitest.ts` (`makeDatabaseIt`)
+  - `@shivaedev/effect-prisma/sqlite`: `@shivaedev/effect-prisma/sqlite.ts`
+- `all`, `and`, `not` and `or` are no longer re-exported: import them from `@prisma-next/sql-orm-client`. `AnyDatabase`, `DatabaseService` and `DatabaseServiceOf` live in `databaseTypes.ts`, moved out of `internal/` because they are public, and `database.ts` and `testing/types.ts` no longer re-export them.
+
 ## 0.7.1 - 2026-10-04
 
 ### Changed

package/README.md

@@ -1,234 +1,277 @@
-# `@shivaedev/effect-prisma`
+# @shivaedev/effect-prisma
 
-Effect-native PostgreSQL queries and transactions backed by Prisma Next.
+Use Prisma Next's generated model queries in Effect, with typed rows, database transactions and tests that roll their writes back. Keep the contract your application already owns while making database work compose with its Effect services.
 
-This package currently targets exact early-access versions of Effect v4 and
-Prisma Next. It is built for ShivaeDev applications and may change without a
-deprecation period.
+## Why you want this
 
-## Install
+A Promise-based database client leaves every Effect application to rebuild the same boundary: translate failures, pass the transaction client through its services and clean up test writes. This package gives that work one Database service:
 
-```sh
-pnpm add @shivaedev/effect-prisma effect
+```ts
+const createUser = Effect.gen(function* () {
+  const db = yield* Database;
+  return yield* db.transaction(
+    Effect.gen(function* () {
+      const tx = yield* Database;
+      return yield* tx.User.create({
+        id: crypto.randomUUID(),
+        email: "ada@example.test",
+        name: "Ada",
+      });
+    }),
+  );
+});
 ```
 
-Generate a Prisma Next contract in the application, then create its database
-service:
+`Database` is your application's exported definition. The transaction body yields that same service and uses the same generated models. A successful body commits; a failed body rolls back. The test harness runs that work in a rollback-only transaction, so a test can create real rows without leaving them behind.
 
-```sh
-prisma-next contract emit
-effect-prisma-normalize path/to/generated/contract.d.ts
-```
+## Using it
+
+### How to think about it
 
-The normalization step is idempotent and currently required because Prisma
-Next's generated PostgreSQL timestamp output declarations do not match its
-runtime `Date` codecs. It fails when Prisma emits an unfamiliar timestamp shape
-instead of silently producing weakened types.
+There are three things to keep separate:
+
+- The **contract** is Prisma Next's description of your database and generated TypeScript model types.
+- A **Database definition** is an Effect service for that contract. Its Layer provides a live database facade.
+- A **Relation** is a reusable model query, such as `db.User.where({ name: "Ada" })`. It is also an Effect: yielding a collection Relation returns its rows.
+
+A Relation keeps the calls that describe its query. Branching it creates another query without changing the base. A root Relation resolves the active transaction when it runs; one made from a transaction facade belongs to that transaction's lifetime and context. You do not provide a separate executor service to queries or Streams.
+
+Organize application work around these boundaries: define the Database and its Layer once, write reusable queries in each feature's repository, and run those Effects or rollback tests every day. The examples use a contract with `User` and `Post` models: users have `id`, `email`, `name`, `createdAt`, `verifiedAt` and `posts`; posts have `title`, `user` and an optional `reviewer`.
+
+### Once per application: define the database
 
 ```ts
-import { makeDatabase } from "@shivaedev/effect-prisma"
-import { contractJson, type Contract } from "./generated/contract.js"
+import { makeDatabase } from "@shivaedev/effect-prisma/database.ts";
+import type { Contract } from "./generated/contract.d.ts";
+import contractJson from "./generated/contract.json" with { type: "json" };
 
 export const Database = makeDatabase<Contract>()("@app/Database", {
   contractJson,
-})
+});
 
 export const DatabaseLive = Database.layer({
-  url: process.env.DATABASE_URL!,
-})
+  url: "postgresql://localhost/application",
+});
 ```
 
-Each identifier names one exported Database definition, and each composed
-runtime provides one live Layer for that definition. Reuse that singleton;
-duplicate identifiers and multiple simultaneous Layers for one definition are
-outside the supported composition.
-
-The Layer owns the PostgreSQL client and closes it with its structured Effect
-scope. Database values do not outlive that scope.
+The type parameter is the generated contract type; `contractJson` is its emitted JSON. Choose one literal identifier for each exported definition. Different identifiers keep two databases distinct even when they use the same contract, including in the types of included queries. Widened strings, unions and template patterns cannot identify one Database.
 
-## SQLite (experimental)
+Reuse the definition and provide one live Layer for it in a composed runtime. Keep values within that Layer's scope: a root Stream or Database facade used after the owning Layer closes fails with `RUNTIME.DATABASE_CLOSED`. A transaction-bound value instead closes with its transaction and fails with `RUNTIME.TRANSACTION_CLOSED` after settlement.
 
-A SQLite contract emitted with `@prisma-next/sqlite` uses the same API through a
-separate entrypoint. Its `DateTime` fields already declare `Date`, so the
-normalization step above is PostgreSQL-only.
+SQLite uses the same query and transaction facade through its own factory:
 
 ```ts
-import { makeSqliteDatabase } from "@shivaedev/effect-prisma/sqlite"
-import { contractJson, type Contract } from "./generated/contract.js"
+import { makeSqliteDatabase } from "@shivaedev/effect-prisma/sqlite.ts";
+import type { Contract } from "./generated/contract.d.ts";
+import contractJson from "./generated/contract.json" with { type: "json" };
 
 export const Database = makeSqliteDatabase<Contract>()("@app/Database", {
   contractJson,
-})
+});
 
-export const DatabaseLive = Database.layer({
-  path: "app.db",
-})
+export const DatabaseLive = Database.layer({ path: "application.db" });
 ```
 
-The Layer applies `journal_mode=WAL` when it connects; pass `pragmas` to change
-that list. Prisma Next's SQLite driver already sets `foreign_keys` and
-`busy_timeout` on every connection it opens, and it opens a separate connection
-per transaction, so in-memory databases are rejected.
+Use a SQLite contract for this definition. The default connect-time pragma sets `journal_mode=WAL`. SQLite's serialization and file requirements are described under limits below.
 
-That driver is synchronous. Queries block the event loop while they run, and
-because SQLite allows a single writer, overlapping write transactions wait for
-`busy_timeout` while blocking that event loop. The supported Database Layer
-therefore serializes finite root query effects and explicit transaction
-lifetimes through one access permit. Transaction-internal queries use a private
-permit for their single connection, while root Streams remain incremental. Do
-not coordinate multiple Database Layers against the same SQLite file.
+### Once per feature: write reusable queries
 
-SQLite stores `DateTime` as text, and `prisma-next db init` generates
-`DEFAULT (datetime('now'))`, which writes a UTC instant without a zone
-designator. The entrypoint decodes zone-less datetime text as UTC, so generated
-column defaults round-trip to the instant SQLite wrote without hand-editing the
-DDL. Values that already carry `Z` or a numeric offset decode unchanged.
-`datetime('now')` itself stores whole seconds; write
-`strftime('%Y-%m-%dT%H:%M:%fZ', 'now')` where a default needs milliseconds.
+```ts
+import { Effect } from "effect";
+import { Database } from "./database.ts";
+
+export const findUsersNamed = (name: string) =>
+  Effect.gen(function* () {
+    const db = yield* Database;
+    const matching = db.User.where({ name });
+    const names = matching.orderBy((user) => user.email.asc()).select("id", "email");
+
+    return {
+      rows: yield* names.take(20),
+      first: yield* matching.first(),
+      exists: yield* matching.exists(),
+      count: yield* matching.count(),
+    };
+  });
+```
 
-## Queries
+`matching` remains the full filtered Relation after `names` adds an order and selection. A selection keeps only its named fields in the result type. `first()` returns an Effect `Option`, `exists()` returns a boolean and `count()` returns a number. Object filters and callback filters retain the contract's field types.
 
-Yield the database service once and use generated models directly:
+Load relations by their contract names:
 
 ```ts
-import { Effect } from "effect"
+export const userPostOverview = Effect.gen(function* () {
+  const db = yield* Database;
+  const titles = db.Post.orderBy((post) => post.title.asc()).select("title");
+  const page = titles.take(1);
+
+  return yield* db.User.include("posts", {
+    items: page,
+    fullCount: db.Post.count(),
+    pageCount: page.count(),
+  });
+});
+```
 
-const program = Effect.gen(function* () {
-  const db = yield* Database
+The `posts` property contains the named projections: a page of titles, the full related count and the page count. `include("posts")` loads the related rows directly; passing a Relation refines them. Includes can nest, as in `db.User.include("posts", db.Post.include("user"))`, and chain, as in `db.Post.include("user").include("reviewer")`. To-many values are arrays; an optional reviewer stays `User | null`.
 
-  const active = db.User.where({ active: true })
-  const newest = active.orderBy((user) => user.createdAt.desc())
+An included query must come from the same Database and use the related model. A named query record must be nonempty and applies only to a to-many relation. The compiler rejects these mismatches; runtime checks also reject foreign databases, wrong models and transaction-bound queries used outside their owner.
 
-  const users = yield* newest.take(20)
-  const first = yield* active.first()
-  const exists = yield* active.exists()
-  const count = yield* active.count()
+For grouped summaries and bulk changes, use the generated collection operations:
 
-  return { users, first, exists, count }
-})
+```ts
+export const renameUsers = (name: string, replacement: string) =>
+  Effect.gen(function* () {
+    const db = yield* Database;
+    const matching = db.User.where({ name });
+    const summary = yield* matching.aggregate((aggregate) => ({
+      total: aggregate.count(),
+    }));
+    const groups = yield* matching.groupBy("name").aggregate((aggregate) => ({
+      total: aggregate.count(),
+    }));
+    const changed = yield* matching.updateAll({ name: replacement });
+    return { summary, groups, changed };
+  });
 ```
 
-Relations are lazy and immutable. Reusing or branching a Relation never changes
-the original, and each Relation closes over the Database implementation that
-created it.
+`aggregate` returns the named summary; grouped aggregates also include the grouped fields. `createAll`, `updateAll` and `deleteAll` return rows. Update and delete methods require an explicit filter in the typed API.
 
-Relations can be loaded directly or refined with another immutable Relation:
+### Every day: run effects and transactions
 
 ```ts
-const recentPosts = db.Post
-  .orderBy((post) => post.createdAt.desc())
-  .take(5)
+const result = await Effect.runPromise(
+  findUsersNamed("Ada").pipe(Effect.provide(DatabaseLive)),
+);
+```
 
-const usersWithPosts = yield* db.User.include("posts", recentPosts)
+Provide the Database Layer to the program that yields its definition. Repository queries remain ordinary Effects that a larger application's Layer can provide.
 
-const usersWithPostCounts = yield* db.User.include("posts", db.Post.count())
-```
+A transaction body must yield its Database definition. The boundary provides that service for the body while retaining any other service requirements. Nested package transactions reuse the active transaction and its facade; they do not create independent rollback boundaries.
 
-Includes can be chained and nested. Loaded to-many relations are arrays, and
-nullable to-one relations remain nullable in the result type.
+A root query captured before a transaction participates when run inside it. A Database, Relation or Stream created from the transaction facade cannot be used after settlement, outside that transaction or in a concurrent sibling transaction. Closed values fail with `RUNTIME.TRANSACTION_CLOSED`; values used in another active context fail with `RUNTIME.TRANSACTION_CONTEXT_MISMATCH`.
 
-Named query records return several projections of the same relation:
+Successful transactions commit. Typed failures and interruption roll back before returning. Queries sharing the transaction connection execute one at a time. Once such a query starts, interruption waits for it to settle before another query or transaction settlement uses the connection.
+
+Collection Relations also expose reusable Streams:
 
 ```ts
-const publishedPosts = db.Post.where({ published: true })
-const recentPublishedPosts = publishedPosts
-  .orderBy((post) => post.createdAt.desc())
-  .take(5)
-
-const usersWithPostOverview = yield* db.User.include("posts", {
-  items: recentPublishedPosts,
-  fullCount: publishedPosts.count(),
-})
+import { Stream } from "effect";
+
+export const userEmails = Effect.gen(function* () {
+  const db = yield* Database;
+  return yield* Stream.runCollect(
+    db.User.select("email").stream.pipe(Stream.map((user) => user.email)),
+  );
+});
 ```
 
-Collections are also cold Effect Streams:
+Outside transactions the source emits incrementally. Inside a transaction the package buffers the source before downstream work runs, so a downstream database query can use the same connection. Account for the full result's memory use in a transaction.
+
+### Every day: test real writes with rollback
+
+Define the application's database test harness once:
 
 ```ts
-const stream = db.User.where({ active: true }).stream
+import { makeDatabaseIt } from "@shivaedev/effect-prisma/testing/vitest.ts";
+import { Database, DatabaseTest } from "./database-test.ts";
+
+export const it = makeDatabaseIt({
+  database: Database,
+  layer: DatabaseTest,
+});
 ```
 
-The package covers scalar models, filtering, selection, relation loading,
-ordering, pagination, distinct queries, aggregates, grouping, and
-create/update/delete terminals. Model variants are deliberately deferred rather
-than exposed with weakened types.
+`DatabaseTest` is the application's Layer for an initialized test database. A test receives the typed facade and Vitest context:
 
-PostgreSQL timestamp and timestamp-with-time-zone fields use JavaScript `Date`
-values for reads, writes, filters, selections, includes, and Streams after the
-generated contract is normalized.
+```ts
+import { expect } from "vitest";
+import { it } from "./database-it.ts";
 
-## Transactions
+it.effectDB("creates a user", function* (db, context) {
+  const email = `${crypto.randomUUID()}@example.test`;
+  const user = yield* db.User.create({
+    id: crypto.randomUUID(),
+    email,
+    name: "Ada",
+  });
 
-Transactions keep the same database API and are implicitly scoped:
+  expect(user.email).toBe(email);
+  expect(context.task.name).toContain("creates a user");
+});
+```
+
+Successful and failing test bodies both roll back their writes. `effectDB.each` takes each table item before the database and context; `effectDB.fails` declares an expected failure. Ordinary transactions nested inside a rollback test share its scope and are rolled back with it.
+
+For another test runner, wrap an Effect with the rollback primitive:
 
 ```ts
-yield* db.transaction(
+import { withTestTransaction } from "@shivaedev/effect-prisma/testing/transaction.ts";
+
+const testProgram = withTestTransaction(
+  Database,
   Effect.gen(function* () {
-    const db = yield* Database
-    yield* db.User.create({
-      id,
-      email,
-      name,
-    })
+    const db = yield* Database;
+    return yield* db.User.count();
   }),
-)
+).pipe(Effect.provide(DatabaseTest));
 ```
 
-Relations from the singleton Database resolve its active transaction when they
-execute, so a Relation created before the boundary still participates when used
-inside it. The Database yielded inside the body is the transaction-bound
-implementation for methods constructed there. A transaction-bound Database or
-Relation is valid only inside that boundary and fails closed if used after
-settlement.
+The primitive returns the body's value or preserves its failure while rolling back. A rollback-only boundary inside an ordinary commit transaction is refused with `RUNTIME.TEST_TRANSACTION_INSIDE_TRANSACTION_UNSUPPORTED`; nesting another boundary inside an existing rollback test shares that test's transaction.
+
+### API
+
+Import the defining module; the package has no root entry point.
 
-Nested package transactions reuse the active transaction. Successful programs
-commit; failure, defect, and interruption roll back. A forced-rollback test
-transaction inside an ordinary commit transaction is refused because the
-drivers do not provide the savepoint semantics that promise would require.
+| Module | Public surface |
+| --- | --- |
+| `database.ts` | `makeDatabase<Contract>()(identifier, { contractJson })`, `DatabaseDefinition`, `DatabaseLayerOptions`. Factory options also accept an already typed `contract`. |
+| `sqlite.ts` | `makeSqliteDatabase<Contract>()(identifier, options)`, `defaultSqlitePragmas`, `SqliteDatabaseDefinition`, `SqliteDatabaseLayerOptions`. Layer options include `path` and `pragmas`. |
+| `databaseTypes.ts` | `DatabaseService<Contract, Identifier>`, `DatabaseServiceOf<typeof Database>`, `AnyDatabase`, `DatabaseIdentifier`, `DatabaseIdentifierLiteral`, `DatabaseServiceHolder`, `DefaultModels`, `SqlDatabase`, `internalContextIdentifierPrefix`. |
+| `relation.ts` | `Relation`, `RelationQuery`, `CollectionResult`. |
+| `error.ts` | `PrismaError`, `PrismaErrorReason`, `PrismaRuntimeFailure`, `PrismaQueryFailure`, `PrismaConnectionFailure`, `isPrismaFailure`, `toPrismaError`. |
+| `testing/vitest.ts` | `makeDatabaseIt({ database, layer, clock? })`. |
+| `testing/transaction.ts` | `withTestTransaction(database, program)` and `withTestTransaction(database)(program)`. |
+| `testing/types.ts` | `DatabaseIt`, `DatabaseTester`, `DatabaseTest`, `DatabaseService`, `MakeDatabaseItOptions`. |
+| `relation/include.ts`, `relation/include-metadata.ts`, `relation/prisma-methods.ts` | Supporting types: `IncludeMethod`, `AnyPostgresContract`, `IsToManyRelation`, `RelatedModelNameOf`, `IncludedRelationValue`, `PrismaRelationMethods`. |
+| `effect-prisma-normalize` | Executable taking one generated contract declaration path. |
 
-Queries composed concurrently inside a transaction are executed one at a time
-on its single connection. Once a transaction query starts, interruption waits
-for it to settle before releasing that connection. PostgreSQL query effects
-outside transactions remain parallel. SQLite root query effects execute one at
-a time and do not overlap an explicit transaction lifetime, so a root write
-cannot invalidate the transaction's WAL snapshot.
+The Relation surface follows Prisma Next's collections. Its typed operations include filters and ordering; `select`, `take`, `cursor`, `distinct`, `distinctOn`; `include`, `count`, `exists`, `first`; `aggregate`, `groupBy`; and create, update and delete terminals. Cursor and distinct-on types require an order first. Import boolean filter combinators such as `and`, `or`, `not` and `all` from `@prisma-next/sql-orm-client`.
 
-Transaction-scoped Streams are read into memory before emitting rows. This
-releases the connection before downstream Stream effects run database queries.
-Streams outside transactions retain incremental fetching.
+A `PrismaError` carries a tagged `reason`. Unique-constraint tests verify `PrismaQueryFailure` with `sqlState` and `constraint`; scope and transaction guards use `PrismaRuntimeFailure` with `code`. Unknown Promise rejections remain defects rather than becoming typed database failures.
 
-## Vitest
+`effectDB` also exposes the declared `skip`, `skipIf`, `runIf` and `only` methods. Its options and factory accept `clock`; see the [Effect test runner](https://github.com/ShivaeDev/platform/tree/main/packages/effect-test#readme) for the shared option types and clock model.
 
-Install `@effect/vitest` to use the optional testing entrypoint:
+### Install and contract setup
 
 ```sh
-pnpm add --save-dev @effect/vitest vitest
+pnpm add @shivaedev/effect-prisma effect@4.0.4
+pnpm add --save-dev @effect/vitest@4.0.4 vitest@5.0.3
 ```
 
-Configure the database once in the application's test support:
+The Vitest dependencies are needed only for `testing/vitest.ts`. Use Node.js 24 or newer and compatible versions of the package's Effect and Prisma Next dependencies.
 
-```ts
-import { makeDatabaseIt } from "@shivaedev/effect-prisma/testing"
+The application owns its Prisma Next CLI/configuration, initialized schema and
+migration workflow. This package does not apply schema changes. Emit that
+application's contract, then normalize its PostgreSQL declaration:
 
-export const it = makeDatabaseIt({
-  database: Database,
-  layer: DatabaseTest,
-})
+```sh
+prisma-next contract emit
+effect-prisma-normalize path/to/generated/contract.d.ts
 ```
 
-Tests receive the typed database facade and always roll back:
+Normalization replaces supported PostgreSQL timestamp declarations with `Date`, preserves other fields and can run twice. An unsupported timestamp declaration fails without overwriting the generated file. PostgreSQL timestamp and timestamp-with-time-zone fields accept and return JavaScript `Date` values; the tests exercise writes, reads and equality filters. SQLite `DateTime` declarations already use `Date` and do not need this PostgreSQL step.
 
-```ts
-it.effectDB("creates a user", function* (db) {
-  const user = yield* db.User.create({
-    id,
-    email,
-    name,
-  })
+SQLite datetime text without a zone is decoded as UTC, including the `datetime('now')` column default. Text that already contains `Z` or a numeric offset is left unchanged. That generated default has whole-second precision.
 
-  expect(user.email).toBe(email)
-})
-```
+### Limits
+
+- Use one exported definition and one live Layer per identifier. Duplicate identifiers or multiple simultaneous Layers for one definition are outside the supported composition.
+- Keep Database values inside their Layer and transaction lifetimes. Return rows from a transaction rather than its facade or queries.
+- PostgreSQL contracts must have one domain namespace. A model named `transaction` conflicts with the facade's transaction method.
+- SQLite needs a file-backed database; `:memory:` and an empty path are rejected. Its driver uses synchronous database calls. Treat it as a local database path and avoid coordinating separate Layers against the same file.
+- One SQLite Layer serializes finite root query Effects with the entire explicit transaction lifetime. Transaction queries have a separate permit. Root Streams remain incremental; do not treat them as holding that lifetime permit.
+- Transaction Streams buffer the full result. Refine large queries before collecting them in a transaction.
+- The API excludes model variants and direct scalar aggregate shortcuts; use the typed `aggregate` callback. Prisma Next features are not automatically package guarantees.
 
-`effectDB` supports the usual `skip`, `skipIf`, `runIf`, `only`, `each`, and
-`fails` variants. Tests install TestClock unless you pass `clock: "live"`.
-`withTestTransaction` is also exported for custom harnesses.
+The [roadmap](https://github.com/ShivaeDev/platform/blob/main/packages/effect-prisma/docs/roadmap.md) records package status and maintainer questions. The tests distinguish real PostgreSQL behavior, file-backed SQLite behavior and controlled execution tests; PostgreSQL tests skip when their database URL is absent.

package/dist/database.d.ts

@@ -1,21 +1,21 @@
 import { type PostgresOptionsBase } from "@prisma-next/postgres/runtime";
 import { type Layer, Redacted } from "effect";
-import type { DatabaseIdentifier, DatabaseIdentifierLiteral, DatabaseServiceHolder } from "#internal/database-types.ts";
+import type { DatabaseIdentifier, DatabaseIdentifierLiteral, DatabaseServiceHolder } from "#databaseTypes.ts";
 import type { AnySqlContract } from "#internal/executor.ts";
 import type { PrismaError } from "./error.ts";
-export type { AnyDatabase, DatabaseService, DatabaseServiceOf, } from "#internal/database-types.ts";
 export interface DatabaseLayerOptions extends PostgresOptionsBase {
     readonly url: string | Redacted.Redacted<string>;
 }
-type DatabaseFactoryOptions<Contract extends AnySqlContract> = {
-    readonly contract: Contract;
+type DatabaseFactoryOptions<TContract extends AnySqlContract> = {
+    readonly contract: TContract;
     readonly contractJson?: never;
 } | {
     readonly contractJson: unknown;
     readonly contract?: never;
 };
-export interface DatabaseDefinition<Contract extends AnySqlContract, Identifier extends string> extends DatabaseServiceHolder<Contract, Identifier> {
-    readonly layer: (options: DatabaseLayerOptions) => Layer.Layer<DatabaseIdentifier<Contract, Identifier>, PrismaError>;
+export interface DatabaseDefinition<TContract extends AnySqlContract, TIdentifier extends string> extends DatabaseServiceHolder<TContract, TIdentifier> {
+    readonly layer: (options: DatabaseLayerOptions) => Layer.Layer<DatabaseIdentifier<TContract, TIdentifier>, PrismaError>;
 }
-export declare const makeDatabase: <const Contract extends AnySqlContract>() => <const Identifier extends string>(identifier: DatabaseIdentifierLiteral<Identifier>, options: DatabaseFactoryOptions<Contract>) => DatabaseDefinition<Contract, Identifier>;
+export declare const makeDatabase: <const TContract extends AnySqlContract>() => <const TIdentifier extends string>(identifier: DatabaseIdentifierLiteral<TIdentifier>, options: DatabaseFactoryOptions<TContract>) => DatabaseDefinition<TContract, TIdentifier>;
+export {};
 //# sourceMappingURL=database.d.ts.map

package/dist/database.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../src/database.ts"],"names":[],"mappings":"AAAA,OAAiB,EAAuB,KAAK,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACxG,OAAO,EAAE,KAAK,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAI9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,qBAAqB,EAAiB,MAAM,6BAA6B,CAAC;AACvI,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,YAAY,EACX,WAAW,EACX,eAAe,EACf,iBAAiB,GACjB,MAAM,6BAA6B,CAAC;AAErC,MAAM,WAAW,oBAAqB,SAAQ,mBAAmB;IAChE,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;CACjD;AAED,KAAK,sBAAsB,CAAC,QAAQ,SAAS,cAAc,IACxD;IACA,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,YAAY,CAAC,EAAE,KAAK,CAAC;CAC7B,GACD;IACA,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC;CACzB,CAAC;AAEL,MAAM,WAAW,kBAAkB,CAAC,QAAQ,SAAS,cAAc,EAAE,UAAU,SAAS,MAAM,CAAE,SAAQ,qBAAqB,CAAC,QAAQ,EAAE,UAAU,CAAC;IAClJ,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,oBAAoB,KAAK,KAAK,CAAC,KAAK,CAAC,kBAAkB,CAAC,QAAQ,EAAE,UAAU,CAAC,EAAE,WAAW,CAAC,CAAC;CACtH;AAaD,eAAO,MAAM,YAAY,GACvB,KAAK,CAAC,QAAQ,SAAS,cAAc,QACrC,KAAK,CAAC,UAAU,SAAS,MAAM,EAC/B,YAAY,yBAAyB,CAAC,UAAU,CAAC,EACjD,SAAS,sBAAsB,CAAC,QAAQ,CAAC,KACvC,kBAAkB,CAAC,QAAQ,EAAE,UAAU,CAgCzC,CAAC"}
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../src/database.ts"],"names":[],"mappings":"AAAA,OAAiB,EAAuB,KAAK,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACxG,OAAO,EAAE,KAAK,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,qBAAqB,EAAiB,MAAM,mBAAmB,CAAC;AAI7H,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,MAAM,WAAW,oBAAqB,SAAQ,mBAAmB;IAChE,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;CACjD;AAED,KAAK,sBAAsB,CAAC,SAAS,SAAS,cAAc,IACzD;IACA,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;IAC7B,QAAQ,CAAC,YAAY,CAAC,EAAE,KAAK,CAAC;CAC7B,GACD;IACA,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC;CACzB,CAAC;AAEL,MAAM,WAAW,kBAAkB,CAAC,SAAS,SAAS,cAAc,EAAE,WAAW,SAAS,MAAM,CAC/F,SAAQ,qBAAqB,CAAC,SAAS,EAAE,WAAW,CAAC;IACrD,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,oBAAoB,KAAK,KAAK,CAAC,KAAK,CAAC,kBAAkB,CAAC,SAAS,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,CAAC;CACxH;AAkBD,eAAO,MAAM,YAAY,GACvB,KAAK,CAAC,SAAS,SAAS,cAAc,QACtC,KAAK,CAAC,WAAW,SAAS,MAAM,cACpB,yBAAyB,CAAC,WAAW,CAAC,WACzC,sBAAsB,CAAC,SAAS,CAAC,KACxC,kBAAkB,CAAC,SAAS,EAAE,WAAW,CAgC3C,CAAC"}

package/dist/database.js

@@ -4,14 +4,18 @@ import { acquireConnectedClient } from "#internal/client-lifecycle.ts";
 import { namespaceModels } from "#internal/database-facade.ts";
 import { makeSqlDatabase } from "#internal/database-factory.ts";
 import { fromPrismaPromise } from "#internal/promise.ts";
-const clientOptions = ({ url, extensions, middleware, poolOptions, verifyMarker }) => ({
-    url: typeof url === "string" ? url : Redacted.value(url),
-    ...(extensions === undefined ? {} : { extensions }),
-    ...(middleware === undefined ? {} : { middleware }),
-    ...(poolOptions === undefined ? {} : { poolOptions }),
-    ...(verifyMarker === undefined ? {} : { verifyMarker }),
-});
-const defaultModels = (client) => namespaceModels(client.contract, client.orm);
+function clientOptions({ url, extensions, middleware, poolOptions, verifyMarker }) {
+    return {
+        url: typeof url === "string" ? url : Redacted.value(url),
+        ...(extensions === undefined ? {} : { extensions }),
+        ...(middleware === undefined ? {} : { middleware }),
+        ...(poolOptions === undefined ? {} : { poolOptions }),
+        ...(verifyMarker === undefined ? {} : { verifyMarker }),
+    };
+}
+function defaultModels(client) {
+    return namespaceModels(client.contract, client.orm);
+}
 export const makeDatabase = () => (identifier, options) => {
     return makeSqlDatabase(identifier, (layerOptions) => {
         const forwarded = clientOptions(layerOptions);

package/dist/database.js.map

@@ -1 +1 @@
-{"version":3,"file":"database.js","sourceRoot":"","sources":["../src/database.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,EAAE,EAAiD,MAAM,+BAA+B,CAAC;AACxG,OAAO,EAAc,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAGhE,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AA2BzD,MAAM,aAAa,GAAG,CAAC,EAAE,GAAG,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAwB,EAAE,EAAE,CAAC,CAAC;IAC5G,GAAG,EAAE,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC;IACxD,GAAG,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC;IACnD,GAAG,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC;IACnD,GAAG,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC;IACrD,GAAG,CAAC,YAAY,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC;CACvD,CAAC,CAAC;AAEH,MAAM,aAAa,GAAG,CAAyD,MAA0D,EAAU,EAAE,CACpJ,eAAe,CAAmB,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;AAEhE,MAAM,CAAC,MAAM,YAAY,GACxB,GAA0C,EAAE,CAC5C,CACC,UAAiD,EACjD,OAAyC,EACE,EAAE;IAG7C,OAAO,eAAe,CAA6C,UAAU,EAAE,CAAC,YAAY,EAAE,EAAE;QAC/F,MAAM,SAAS,GAAG,aAAa,CAAC,YAAY,CAAC,CAAC;QAC9C,MAAM,MAAM,GACX,OAAO,CAAC,QAAQ,KAAK,SAAS;YAC7B,CAAC,CAAC,QAAQ,CAAW;gBACnB,GAAG,SAAS;gBACZ,YAAY,EAAE,OAAO,CAAC,YAAY;aAClC,CAAC;YACH,CAAC,CAAC,QAAQ,CAAW;gBACnB,GAAG,SAAS;gBACZ,QAAQ,EAAE,OAAO,CAAC,QAAQ;aAC1B,CAAC,CAAC;QAEN,OAAO,iBAAiB,CAAC,GAAG,EAAE,CAC7B,sBAAsB,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC;YACrC,MAAM;YACN,QAAQ,EAAE,EAAE;YACZ,QAAQ,EAAE;gBACT,UAAU,EAAE,yBAAyB;gBACrC,IAAI,EAAE,IAAI;aACV;YACD,IAAI,EAAE,MAAM;YACZ,MAAM,EAAE,aAAa,CAAmB,MAAM,CAAC;YAC/C,cAAc,EAAE,SAAS;YACzB,mBAAmB,EAAE,SAAS;YAC9B,oBAAoB,EAAE,SAAS;SAC/B,CAAC,CAAC,CACH,CAAC;IACH,CAAC,CAAC,CAAC;AACJ,CAAC,CAAC"}
+{"version":3,"file":"database.js","sourceRoot":"","sources":["../src/database.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,EAAE,EAAiD,MAAM,+BAA+B,CAAC;AACxG,OAAO,EAAc,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAE9C,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAEhE,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAsBzD,SAAS,aAAa,CAAC,EAAE,GAAG,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAwB;IACtG,OAAO;QACN,GAAG,EAAE,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC;QACxD,GAAG,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC;QACnD,GAAG,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC;QACnD,GAAG,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC;QACrD,GAAG,CAAC,YAAY,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC;KACvD,CAAC;AACH,CAAC;AAED,SAAS,aAAa,CACrB,MAA2D;IAE3D,OAAO,eAAe,CAAqB,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;AACzE,CAAC;AAED,MAAM,CAAC,MAAM,YAAY,GACxB,GAA2C,EAAE,CAC7C,CACC,UAAkD,EAClD,OAA0C,EACG,EAAE;IAG/C,OAAO,eAAe,CAA+C,UAAU,EAAE,CAAC,YAAY,EAAE,EAAE;QACjG,MAAM,SAAS,GAAG,aAAa,CAAC,YAAY,CAAC,CAAC;QAC9C,MAAM,MAAM,GACX,OAAO,CAAC,QAAQ,KAAK,SAAS;YAC7B,CAAC,CAAC,QAAQ,CAAY;gBACpB,GAAG,SAAS;gBACZ,YAAY,EAAE,OAAO,CAAC,YAAY;aAClC,CAAC;YACH,CAAC,CAAC,QAAQ,CAAY;gBACpB,GAAG,SAAS;gBACZ,QAAQ,EAAE,OAAO,CAAC,QAAQ;aAC1B,CAAC,CAAC;QAEN,OAAO,iBAAiB,CAAC,GAAG,EAAE,CAC7B,sBAAsB,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC;YACrC,MAAM;YACN,QAAQ,EAAE,EAAE;YACZ,QAAQ,EAAE;gBACT,UAAU,EAAE,yBAAyB;gBACrC,IAAI,EAAE,IAAI;aACV;YACD,IAAI,EAAE,MAAM;YACZ,MAAM,EAAE,aAAa,CAAoB,MAAM,CAAC;YAChD,cAAc,EAAE,SAAS;YACzB,mBAAmB,EAAE,SAAS;YAC9B,oBAAoB,EAAE,SAAS;SAC/B,CAAC,CAAC,CACH,CAAC;IACH,CAAC,CAAC,CAAC;AACJ,CAAC,CAAC"}

package/dist/databaseTypes.d.ts

@@ -0,0 +1,33 @@
+import type { orm } from "@prisma-next/sql-orm-client";
+import type { Context, Effect, Layer } from "effect";
+import type { PrismaError } from "#error.ts";
+import type { AnySqlContract } from "#internal/executor.ts";
+import type { Relation } from "#relation.ts";
+type OrmFor<TContract extends AnySqlContract> = ReturnType<typeof orm<TContract>>;
+type DefaultNamespaceId<TContract extends AnySqlContract> = "__unbound__" extends keyof OrmFor<TContract> ? "__unbound__" : "public" extends keyof OrmFor<TContract> ? "public" : keyof OrmFor<TContract>;
+export type DefaultModels<TContract extends AnySqlContract> = OrmFor<TContract>[DefaultNamespaceId<TContract>] extends infer TModels extends object ? TModels : never;
+type IsUnion<TValue, TWhole = TValue> = TValue extends unknown ? ([TWhole] extends [TValue] ? false : true) : never;
+type IsSingletonString<TValue extends string> = Record<never, never> extends Record<TValue, never> ? false : true;
+export declare const internalContextIdentifierPrefix = "\0@shivaedev/effect-prisma/internal/";
+export type DatabaseIdentifierLiteral<TIdentifier extends string> = [TIdentifier] extends [`\0@shivaedev/effect-prisma/internal/${string}`] ? never : string extends TIdentifier ? never : true extends IsUnion<TIdentifier> ? never : IsSingletonString<TIdentifier> extends true ? TIdentifier : never;
+export interface DatabaseIdentifier<TContract extends AnySqlContract, TIdentifier extends string> {
+    readonly _contract: (contract: TContract) => TContract;
+    readonly _databaseIdentifier: (identifier: TIdentifier) => TIdentifier;
+}
+type DatabaseModels<TContract extends AnySqlContract, TIdentifier extends string> = {
+    readonly [TModel in keyof DefaultModels<TContract>]: Relation<DefaultModels<TContract>[TModel], TContract, TModel & string, DatabaseIdentifier<TContract, TIdentifier>>;
+};
+export type DatabaseService<TContract extends AnySqlContract, TIdentifier extends string> = DatabaseModels<TContract, TIdentifier> & {
+    transaction: <A, E, R>(program: Effect.Effect<A, E, R> & (DatabaseIdentifier<TContract, TIdentifier> extends R ? unknown : never)) => Effect.Effect<A, E | PrismaError, Exclude<R, DatabaseIdentifier<TContract, TIdentifier>>>;
+};
+export interface DatabaseServiceHolder<TContract extends AnySqlContract, TIdentifier extends string> extends Context.Service<DatabaseIdentifier<TContract, TIdentifier>, DatabaseService<TContract, TIdentifier>> {
+}
+export type AnyDatabase = Effect.Effect<unknown, never, unknown> & {
+    readonly layer: (...arguments_: readonly never[]) => Layer.Any;
+};
+export type DatabaseServiceOf<TDatabase extends AnyDatabase> = Effect.Success<TDatabase>;
+export interface SqlDatabase<TContract extends AnySqlContract, TIdentifier extends string, TOptions> extends DatabaseServiceHolder<TContract, TIdentifier> {
+    readonly layer: (options: TOptions) => Layer.Layer<DatabaseIdentifier<TContract, TIdentifier>, PrismaError>;
+}
+export {};
+//# sourceMappingURL=databaseTypes.d.ts.map

package/dist/databaseTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"databaseTypes.d.ts","sourceRoot":"","sources":["../src/databaseTypes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,6BAA6B,CAAC;AACvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C,KAAK,MAAM,CAAC,SAAS,SAAS,cAAc,IAAI,UAAU,CAAC,OAAO,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC;AAClF,KAAK,kBAAkB,CAAC,SAAS,SAAS,cAAc,IAAI,aAAa,SAAS,MAAM,MAAM,CAAC,SAAS,CAAC,GACtG,aAAa,GACb,QAAQ,SAAS,MAAM,MAAM,CAAC,SAAS,CAAC,GACvC,QAAQ,GACR,MAAM,MAAM,CAAC,SAAS,CAAC,CAAC;AAC5B,MAAM,MAAM,aAAa,CAAC,SAAS,SAAS,cAAc,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,SAAS,MAAM,OAAO,SAAS,MAAM,GAChJ,OAAO,GACP,KAAK,CAAC;AAET,KAAK,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI,MAAM,SAAS,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC,GAAG,KAAK,CAAC;AAEpH,KAAK,iBAAiB,CAAC,MAAM,SAAS,MAAM,IAAI,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC;AAElH,eAAO,MAAM,+BAA+B,yCAAyC,CAAC;AAEtF,MAAM,MAAM,yBAAyB,CAAC,WAAW,SAAS,MAAM,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,uCAAuC,MAAM,EAAE,CAAC,GACxI,KAAK,GACL,MAAM,SAAS,WAAW,GACzB,KAAK,GACL,IAAI,SAAS,OAAO,CAAC,WAAW,CAAC,GAChC,KAAK,GACL,iBAAiB,CAAC,WAAW,CAAC,SAAS,IAAI,GAC1C,WAAW,GACX,KAAK,CAAC;AAEZ,MAAM,WAAW,kBAAkB,CAAC,SAAS,SAAS,cAAc,EAAE,WAAW,SAAS,MAAM;IAC/F,QAAQ,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,SAAS,CAAC;IACvD,QAAQ,CAAC,mBAAmB,EAAE,CAAC,UAAU,EAAE,WAAW,KAAK,WAAW,CAAC;CACvE;AAED,KAAK,cAAc,CAAC,SAAS,SAAS,cAAc,EAAE,WAAW,SAAS,MAAM,IAAI;IACnF,QAAQ,EAAE,MAAM,IAAI,MAAM,aAAa,CAAC,SAAS,CAAC,GAAG,QAAQ,CAC5D,aAAa,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,EAChC,SAAS,EACT,MAAM,GAAG,MAAM,EACf,kBAAkB,CAAC,SAAS,EAAE,WAAW,CAAC,CAC1C;CACD,CAAC;AAEF,MAAM,MAAM,eAAe,CAAC,SAAS,SAAS,cAAc,EAAE,WAAW,SAAS,MAAM,IAAI,cAAc,CAAC,SAAS,EAAE,WAAW,CAAC,GAAG;IACpI,WAAW,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACpB,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,kBAAkB,CAAC,SAAS,EAAE,WAAW,CAAC,SAAS,CAAC,GAAG,OAAO,GAAG,KAAK,CAAC,KACtG,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,WAAW,EAAE,OAAO,CAAC,CAAC,EAAE,kBAAkB,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;CAC/F,CAAC;AAEF,MAAM,WAAW,qBAAqB,CAAC,SAAS,SAAS,cAAc,EAAE,WAAW,SAAS,MAAM,CAClG,SAAQ,OAAO,CAAC,OAAO,CAAC,kBAAkB,CAAC,SAAS,EAAE,WAAW,CAAC,EAAE,eAAe,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;CAAG;AAEhH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,CAAC,GAAG;IAClE,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,UAAU,EAAE,SAAS,KAAK,EAAE,KAAK,KAAK,CAAC,GAAG,CAAC;CAC/D,CAAC;AAEF,MAAM,MAAM,iBAAiB,CAAC,SAAS,SAAS,WAAW,IAAI,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;AAEzF,MAAM,WAAW,WAAW,CAAC,SAAS,SAAS,cAAc,EAAE,WAAW,SAAS,MAAM,EAAE,QAAQ,CAClG,SAAQ,qBAAqB,CAAC,SAAS,EAAE,WAAW,CAAC;IACrD,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAK,KAAK,CAAC,KAAK,CAAC,kBAAkB,CAAC,SAAS,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,CAAC;CAC5G"}

package/dist/{internal/database-types.js → databaseTypes.js}

@@ -1,2 +1,2 @@
 export const internalContextIdentifierPrefix = "\0@shivaedev/effect-prisma/internal/";
-//# sourceMappingURL=database-types.js.map
+//# sourceMappingURL=databaseTypes.js.map

package/dist/databaseTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"databaseTypes.js","sourceRoot":"","sources":["../src/databaseTypes.ts"],"names":[],"mappings":"AAoBA,MAAM,CAAC,MAAM,+BAA+B,GAAG,sCAAsC,CAAC"}

package/dist/error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,QAAQ,EAAE,MAAM,QAAQ,CAAC;;;;AAExC,qBAAa,oBAAqB,SAAQ,0BAAyC;IAClF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;CAC9C,CAAC;CAAG;;;;AAEL,qBAAa,kBAAmB,SAAQ,wBAAuC;IAC9E,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;CAC9C,CAAC;CAAG;;;;AAEL,qBAAa,uBAAwB,SAAQ,6BAA4C;IACxF,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACzC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;CAC9C,CAAC;CAAG;AAEL,MAAM,MAAM,iBAAiB,GAAG,oBAAoB,GAAG,kBAAkB,GAAG,uBAAuB,CAAC;;;;AAEpG,qBAAa,WAAY,SAAQ,iBAAgC;IAChE,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;CACnC,CAAC;CAAG;AAEL,KAAK,aAAa,GACf;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACzB;IACA,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CACxB,GACD;IACA,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEL,eAAO,MAAM,eAAe,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,aAQzD,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,OAAO,aAAa,KAAG,WA4BpD,CAAC"}
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,QAAQ,EAAE,MAAM,QAAQ,CAAC;;;;AAExC,qBAAa,oBAAqB,SAAQ,0BAAyC;IAClF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;CAC9C,CAAC;CAAG;;;;AAEL,qBAAa,kBAAmB,SAAQ,wBAAuC;IAC9E,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;CAC9C,CAAC;CAAG;;;;AAEL,qBAAa,uBAAwB,SAAQ,6BAA4C;IACxF,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACzC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;CAC9C,CAAC;CAAG;AAEL,MAAM,MAAM,iBAAiB,GAAG,oBAAoB,GAAG,kBAAkB,GAAG,uBAAuB,CAAC;;;;AAEpG,qBAAa,WAAY,SAAQ,iBAAgC;IAChE,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;CACnC,CAAC;CAAG;AAEL,KAAK,aAAa,GACf;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACzB;IACA,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CACxB,GACD;IACA,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEL,eAAO,MAAM,eAAe,UAAW,OAAO,KAAG,KAAK,IAAI,aAQzD,CAAC;AAEF,eAAO,MAAM,aAAa,UAAW,aAAa,KAAG,WA4BpD,CAAC"}