prisma-effect-schema-generator 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cyberistic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,179 @@
+# prisma-effect-schema-generator
+
+A standalone [Prisma](https://www.prisma.io) generator that emits
+[Effect Schema](https://effect.website/docs/schema) values for every
+model in your `schema.prisma`. Drop-in runtime validation for your
+database rows — perfect for sync engines, RPC layers, or anywhere you
+need to assert that what you read from the DB actually matches what
+your code expects.
+
+A real-world example: the generator powers the schemas in
+[`Cyberistic/livestore-tanstackdb`](https://github.com/Cyberistic/livestore-tanstackdb)
+where a single `schema.prisma` drives both the Prisma/D1 DDL and the
+LiveStore client-side validation.
+
+```prisma
+generator effect_client {
+  provider = "prisma-effect-schema-generator"
+}
+
+model User {
+  id    String  @id
+  email String
+  role  Role
+}
+
+enum Role {
+  ADMIN
+  USER
+}
+```
+
+```ts
+// generated/effect-schemas/index.ts (auto-generated)
+import { Schema } from "effect"
+
+export const UserSchema = Schema.Struct({
+  id: Schema.String,
+  email: Schema.String,
+  role: Schema.Union(Schema.Literal("ADMIN"), Schema.Literal("USER")),
+})
+
+export type ModelName = | "User"
+export const ALL_MODEL_NAMES = ["User"] as const
+```
+
+```ts
+// your code
+import { Schema } from "effect"
+import { UserSchema } from "./generated/effect-schemas"
+
+const user = Schema.decodeUnknownSync(UserSchema)(rowFromDatabase)
+// user is fully typed as { id: string; email: string; role: "ADMIN" | "USER" }
+```
+
+## Install
+
+```bash
+npm install --save-dev prisma-effect-schema-generator
+npm install effect         # the generator emits `Schema.X` from `effect`
+```
+
+## Configure
+
+Add the generator to your `schema.prisma`:
+
+```prisma
+generator effect_client {
+  provider = "prisma-effect-schema-generator"
+  output   = "./generated/effect-schemas/index.ts"  // optional
+}
+```
+
+Run `npx prisma generate` and the file at `output` is created (or
+updated) on every regeneration.
+
+### All options
+
+| Option                | Default              | Description                                                                                                       |
+|-----------------------|----------------------|-------------------------------------------------------------------------------------------------------------------|
+| `output`              | `./generated/effect-schemas/index.ts` | Where to write the generated module. Relative to the schema file's directory. |
+| `effectImport`        | `"effect"`           | Module specifier to import `Schema` from. Use `"@livestore/utils/effect"` if you live inside that ecosystem.       |
+| `effectImportName`    | `"Schema"`           | Local binding name. Set to e.g. `"S"` to import as `Schema as S`.                                                 |
+| `bigIntAs`            | `"BigIntFromSelf"`   | `"BigInt"` (string-encoded) or `"BigIntFromSelf"` (accepts native bigint).                                        |
+| `decimalAs`           | `"String"`           | `"String"` (precision-safe) or `"Number"` (lossy but ergonomic).                                                  |
+| `dateAs`              | `"DateFromSelf"`     | `"Date"` (ISO-string codec) or `"DateFromSelf"` (accepts native `Date`).                                          |
+| `exportModelNames`    | `"true"`             | Emit `export const ALL_MODEL_NAMES = [...] as const`.                                                             |
+| `exportModelNameType` | `"true"`             | Emit `export type ModelName = "X" | "Y"`.                                                                          |
+
+```prisma
+generator effect_client {
+  provider            = "prisma-effect-schema-generator"
+  output              = "./generated/effect-schemas/index.ts"
+  effectImport        = "effect"
+  effectImportName    = "Schema"
+  bigIntAs            = "BigIntFromSelf"
+  decimalAs           = "String"
+  dateAs              = "DateFromSelf"
+  exportModelNames    = "true"
+  exportModelNameType = "true"
+}
+```
+
+## Type mapping
+
+| Prisma field       | Effect Schema (default)        | Encoded → Decoded                  |
+|--------------------|--------------------------------|------------------------------------|
+| `String`           | `Schema.String`                | string → string                    |
+| `Int`              | `Schema.Number`                | number → number                    |
+| `Float`            | `Schema.Number`                | number → number                    |
+| `BigInt`           | `Schema.BigIntFromSelf`        | bigint → bigint                    |
+| `Decimal`          | `Schema.String`                | string → string (precision-safe)   |
+| `Boolean`          | `Schema.Boolean`               | boolean → boolean                  |
+| `DateTime`         | `Schema.DateFromSelf`          | Date → Date                        |
+| `Json`             | `Schema.Unknown`               | unknown → unknown                  |
+| `Bytes`            | `Schema.Uint8Array`            | number[] → Uint8Array              |
+| enum `<E>`         | `Schema.Union(Schema.Literal(...)...)` | string → string (literal type) |
+
+Wrappers:
+
+| Prisma modifier | Wrapper                           |
+|-----------------|-----------------------------------|
+| `field?`        | `Schema.NullOr(...)`              |
+| `field[]`       | `Schema.Array(...)`               |
+| `field[]?`      | `Schema.NullOr(Schema.Array(...))` |
+
+Relations (object-typed fields) are skipped — the model itself is the
+representation, so re-emitting it as a nested schema would be redundant.
+If you need to validate the related entity, just compose the related
+schema yourself.
+
+## Programmatic use
+
+The generator can be driven without Prisma, e.g. for build scripts or
+custom tooling:
+
+```ts
+import { runGenerator, resolveOptions } from "prisma-effect-schema-generator"
+
+runGenerator({
+  output: "./out.ts",
+  schemaDir: process.cwd(),
+  datamodel: {
+    models: [
+      {
+        name: "User",
+        dbName: null,
+        fields: [
+          { kind: "scalar", name: "id", type: "String", isRequired: true, isList: false },
+          { kind: "scalar", name: "email", type: "String", isRequired: true, isList: false },
+        ],
+      },
+    ],
+    enums: [],
+  },
+  rawConfig: resolveOptions({ bigIntAs: "BigInt" }),
+})
+```
+
+Lower-level building blocks (`renderModule`, `prismaFieldToEffectSchema`,
+`enumToSchema`, `shouldQuoteName`, ...) are also exported.
+
+## Requirements
+
+- Node.js >= 18
+- Prisma 7+ (the `@prisma/generator-helper@7` API)
+- `effect` 3.x or 4.x (peer dependency)
+
+## Development
+
+```bash
+npm install
+npm run build      # tsc -> dist/
+npm test           # vitest
+npm run typecheck  # tsc --noEmit
+```
+
+## License
+
+MIT

package/dist/config.d.ts

@@ -0,0 +1,26 @@
+import type { ResolvedOptions } from "./types.js";
+/**
+ * The defaults applied when the user doesn't supply a config key.
+ *
+ * Kept here (not in `types.ts`) so they live next to the code that
+ * consumes them and the surface area is easy to skim.
+ */
+export declare const DEFAULTS: {
+    readonly effectImport: "effect";
+    readonly effectImportName: "Schema";
+    readonly bigIntAs: "BigIntFromSelf";
+    readonly decimalAs: "String";
+    readonly dateAs: "DateFromSelf";
+    readonly exportModelNames: true;
+    readonly exportModelNameType: true;
+};
+type RawConfig = Record<string, string | string[] | boolean | undefined>;
+/**
+ * Resolve user-supplied options against {@link DEFAULTS}.
+ *
+ * Unknown keys are dropped silently — Prisma forwards arbitrary strings
+ * and we don't want to fail on a typo we don't even use.
+ */
+export declare function resolveOptions(raw: RawConfig | undefined | null): ResolvedOptions;
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;;;;;GAKG;AACH,eAAO,MAAM,QAAQ;;;;;;;;CAQe,CAAC;AAErC,KAAK,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,GAAG,SAAS,CAAC,CAAC;AAkBzE;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,SAAS,GAAG,SAAS,GAAG,IAAI,GAAG,eAAe,CAWjF"}

package/dist/config.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULTS = void 0;
+exports.resolveOptions = resolveOptions;
+/**
+ * The defaults applied when the user doesn't supply a config key.
+ *
+ * Kept here (not in `types.ts`) so they live next to the code that
+ * consumes them and the surface area is easy to skim.
+ */
+exports.DEFAULTS = {
+    effectImport: "effect",
+    effectImportName: "Schema",
+    bigIntAs: "BigIntFromSelf",
+    decimalAs: "String",
+    dateAs: "DateFromSelf",
+    exportModelNames: true,
+    exportModelNameType: true,
+};
+/**
+ * Normalise a string-or-boolean into a real boolean.
+ *
+ * Prisma passes all generator options as strings, so users write
+ * `exportModelNames = "false"` to turn the feature off. We accept a real
+ * `boolean` too for direct programmatic use (tests, programmatic APIs).
+ */
+function toBool(v, fallback) {
+    if (typeof v === "boolean")
+        return v;
+    if (typeof v === "string") {
+        if (v === "true")
+            return true;
+        if (v === "false")
+            return false;
+    }
+    return fallback;
+}
+/**
+ * Resolve user-supplied options against {@link DEFAULTS}.
+ *
+ * Unknown keys are dropped silently — Prisma forwards arbitrary strings
+ * and we don't want to fail on a typo we don't even use.
+ */
+function resolveOptions(raw) {
+    const cfg = raw ?? {};
+    return {
+        effectImport: stringOr(cfg.effectImport, exports.DEFAULTS.effectImport),
+        effectImportName: stringOr(cfg.effectImportName, exports.DEFAULTS.effectImportName),
+        bigIntAs: enumOr(cfg.bigIntAs, exports.DEFAULTS.bigIntAs, ["BigInt", "BigIntFromSelf"]),
+        decimalAs: enumOr(cfg.decimalAs, exports.DEFAULTS.decimalAs, ["String", "Number"]),
+        dateAs: enumOr(cfg.dateAs, exports.DEFAULTS.dateAs, ["Date", "DateFromSelf"]),
+        exportModelNames: toBool(cfg.exportModelNames, exports.DEFAULTS.exportModelNames),
+        exportModelNameType: toBool(cfg.exportModelNameType, exports.DEFAULTS.exportModelNameType),
+    };
+}
+function stringOr(v, fallback) {
+    return typeof v === "string" && v.length > 0 ? v : fallback;
+}
+function enumOr(v, fallback, allowed) {
+    if (typeof v === "string" && allowed.includes(v)) {
+        return v;
+    }
+    return fallback;
+}
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":";;;AA0CA,wCAWC;AAnDD;;;;;GAKG;AACU,QAAA,QAAQ,GAAG;IACtB,YAAY,EAAE,QAAQ;IACtB,gBAAgB,EAAE,QAAQ;IAC1B,QAAQ,EAAE,gBAAgB;IAC1B,SAAS,EAAE,QAAQ;IACnB,MAAM,EAAE,cAAc;IACtB,gBAAgB,EAAE,IAAI;IACtB,mBAAmB,EAAE,IAAI;CACS,CAAC;AAIrC;;;;;;GAMG;AACH,SAAS,MAAM,CAAC,CAAU,EAAE,QAAiB;IAC3C,IAAI,OAAO,CAAC,KAAK,SAAS;QAAE,OAAO,CAAC,CAAC;IACrC,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;QAC1B,IAAI,CAAC,KAAK,MAAM;YAAE,OAAO,IAAI,CAAC;QAC9B,IAAI,CAAC,KAAK,OAAO;YAAE,OAAO,KAAK,CAAC;IAClC,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;;GAKG;AACH,SAAgB,cAAc,CAAC,GAAiC;IAC9D,MAAM,GAAG,GAAG,GAAG,IAAI,EAAE,CAAC;IACtB,OAAO;QACL,YAAY,EAAE,QAAQ,CAAC,GAAG,CAAC,YAAY,EAAE,gBAAQ,CAAC,YAAY,CAAC;QAC/D,gBAAgB,EAAE,QAAQ,CAAC,GAAG,CAAC,gBAAgB,EAAE,gBAAQ,CAAC,gBAAgB,CAAC;QAC3E,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,gBAAQ,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC;QAC/E,SAAS,EAAE,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,gBAAQ,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;QAC1E,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,gBAAQ,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;QACrE,gBAAgB,EAAE,MAAM,CAAC,GAAG,CAAC,gBAAgB,EAAE,gBAAQ,CAAC,gBAAgB,CAAC;QACzE,mBAAmB,EAAE,MAAM,CAAC,GAAG,CAAC,mBAAmB,EAAE,gBAAQ,CAAC,mBAAmB,CAAC;KACnF,CAAC;AACJ,CAAC;AAED,SAAS,QAAQ,CAAC,CAAU,EAAE,QAAgB;IAC5C,OAAO,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;AAC9D,CAAC;AAED,SAAS,MAAM,CACb,CAAU,EACV,QAAW,EACX,OAAqB;IAErB,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAK,OAA6B,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;QACxE,OAAO,CAAM,CAAC;IAChB,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/generator.d.ts

@@ -0,0 +1,61 @@
+import type { DMMFDatamodelLike } from "./types.js";
+/**
+ * Resolve the output file path the user asked for, against the schema
+ * directory Prisma tells us about.
+ *
+ * - `output` may be an absolute path or relative.
+ * - When relative, it's pinned to the schema file's directory so the
+ *   generator behaves the same way no matter where Prisma invokes us
+ *   from.
+ * - When the user didn't set `output`, we use `defaultOutput` from the
+ *   manifest (relative to the schema directory).
+ */
+export declare function resolveOutputPath(outputRaw: string | undefined, schemaDir: string, fallback: string): string;
+/**
+ * The actual generator. Pure of side effects beyond writing the file
+ * and talking to Prisma -- easy to unit-test by calling
+ * {@link runGenerator} with a fake `GeneratorOptions`.
+ */
+export declare function runGenerator(opts: {
+    output: string;
+    schemaDir: string;
+    datamodel: DMMFDatamodelLike;
+    rawConfig: Record<string, string | string[] | boolean | undefined> | undefined;
+}): {
+    outputPath: string;
+    code: string;
+};
+/**
+ * Adapter that wraps {@link runGenerator} with the shape Prisma's
+ * generator-helper expects.
+ *
+ * Exposed so tests can drive the same code path that Prisma calls.
+ */
+export declare function onGenerate(prismaOptions: {
+    generator: {
+        output?: {
+            value: string | null;
+        } | null;
+        config: Record<string, string | string[] | boolean | undefined>;
+    };
+    dmmf: {
+        datamodel: DMMFDatamodelLike;
+    };
+    schemaPath: string;
+}): Promise<void>;
+/**
+ * Register the generator with Prisma. The `prisma generate` command
+ * spawns the generator binary, which calls `generatorHandler(...)`,
+ * which in turn fires `onManifest` and `onGenerate`.
+ *
+ * Calling this at the top of the CJS entry is what wires everything up.
+ */
+export declare function register(): void;
+export { resolveOptions } from "./config.js";
+export { renderModule } from "./render.js";
+export type { DMMFDatamodelLike, DMMFEnumLike, DMMFFieldLike, DMMFModelLike, GeneratorOptionsConfig, ResolvedOptions, } from "./types.js";
+export declare const _internal: {
+    PKG_NAME: string;
+    PKG_VERSION: string;
+};
+//# sourceMappingURL=generator.d.ts.map

package/dist/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../src/generator.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAKpD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GACf,MAAM,CAGR;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,iBAAiB,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,GAAG,SAAS,CAAC,GAAG,SAAS,CAAC;CAChF,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAOvC;AAED;;;;;GAKG;AACH,wBAAsB,UAAU,CAAC,aAAa,EAAE;IAC9C,SAAS,EAAE;QACT,MAAM,CAAC,EAAE;YAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;SAAE,GAAG,IAAI,CAAC;QACzC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,GAAG,SAAS,CAAC,CAAC;KACjE,CAAC;IACF,IAAI,EAAE;QAAE,SAAS,EAAE,iBAAiB,CAAA;KAAE,CAAC;IACvC,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC,IAAI,CAAC,CAOhB;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,IAAI,IAAI,CAa/B;AAKD,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,YAAY,EACV,iBAAiB,EACjB,YAAY,EACZ,aAAa,EACb,aAAa,EACb,sBAAsB,EACtB,eAAe,GAChB,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,SAAS;;;CAA4B,CAAC"}

package/dist/generator.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._internal = exports.renderModule = exports.resolveOptions = void 0;
+exports.resolveOutputPath = resolveOutputPath;
+exports.runGenerator = runGenerator;
+exports.onGenerate = onGenerate;
+exports.register = register;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const generator_helper_1 = require("@prisma/generator-helper");
+const config_js_1 = require("./config.js");
+const render_js_1 = require("./render.js");
+const PKG_NAME = "prisma-effect-schema-generator";
+const PKG_VERSION = "0.1.0";
+/**
+ * Resolve the output file path the user asked for, against the schema
+ * directory Prisma tells us about.
+ *
+ * - `output` may be an absolute path or relative.
+ * - When relative, it's pinned to the schema file's directory so the
+ *   generator behaves the same way no matter where Prisma invokes us
+ *   from.
+ * - When the user didn't set `output`, we use `defaultOutput` from the
+ *   manifest (relative to the schema directory).
+ */
+function resolveOutputPath(outputRaw, schemaDir, fallback) {
+    const out = outputRaw && outputRaw.length > 0 ? outputRaw : fallback;
+    return (0, node_path_1.isAbsolute)(out) ? out : (0, node_path_1.resolve)(schemaDir, out);
+}
+/**
+ * The actual generator. Pure of side effects beyond writing the file
+ * and talking to Prisma -- easy to unit-test by calling
+ * {@link runGenerator} with a fake `GeneratorOptions`.
+ */
+function runGenerator(opts) {
+    const options = (0, config_js_1.resolveOptions)(opts.rawConfig);
+    const code = (0, render_js_1.renderModule)(opts.datamodel, options);
+    const outputPath = resolveOutputPath(opts.output, opts.schemaDir, "./generated/effect-schemas/index.ts");
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(outputPath), { recursive: true });
+    (0, node_fs_1.writeFileSync)(outputPath, code, "utf8");
+    return { outputPath, code };
+}
+/**
+ * Adapter that wraps {@link runGenerator} with the shape Prisma's
+ * generator-helper expects.
+ *
+ * Exposed so tests can drive the same code path that Prisma calls.
+ */
+async function onGenerate(prismaOptions) {
+    runGenerator({
+        output: prismaOptions.generator.output?.value ?? "",
+        schemaDir: (0, node_path_1.dirname)(prismaOptions.schemaPath),
+        datamodel: prismaOptions.dmmf.datamodel,
+        rawConfig: prismaOptions.generator.config,
+    });
+}
+/**
+ * Register the generator with Prisma. The `prisma generate` command
+ * spawns the generator binary, which calls `generatorHandler(...)`,
+ * which in turn fires `onManifest` and `onGenerate`.
+ *
+ * Calling this at the top of the CJS entry is what wires everything up.
+ */
+function register() {
+    (0, generator_helper_1.generatorHandler)({
+        onManifest() {
+            return {
+                defaultOutput: "./generated/effect-schemas/index.ts",
+                prettyName: "Effect Schema Generator",
+                version: PKG_VERSION,
+            };
+        },
+        async onGenerate(options) {
+            await onGenerate(options);
+        },
+    });
+}
+// Re-export the building blocks so programmatic consumers can drive
+// the generator without going through Prisma at all (handy for
+// snapshot tests, embedding in build scripts, etc.).
+var config_js_2 = require("./config.js");
+Object.defineProperty(exports, "resolveOptions", { enumerable: true, get: function () { return config_js_2.resolveOptions; } });
+var render_js_2 = require("./render.js");
+Object.defineProperty(exports, "renderModule", { enumerable: true, get: function () { return render_js_2.renderModule; } });
+exports._internal = { PKG_NAME, PKG_VERSION };
+//# sourceMappingURL=generator.js.map

package/dist/generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.js","sourceRoot":"","sources":["../src/generator.ts"],"names":[],"mappings":";;;AAqBA,8CAOC;AAOD,oCAYC;AAQD,gCAcC;AASD,4BAaC;AA3FD,qCAAmD;AACnD,yCAAyD;AACzD,+DAA4D;AAC5D,2CAA6C;AAC7C,2CAA2C;AAG3C,MAAM,QAAQ,GAAG,gCAAgC,CAAC;AAClD,MAAM,WAAW,GAAG,OAAO,CAAC;AAE5B;;;;;;;;;;GAUG;AACH,SAAgB,iBAAiB,CAC/B,SAA6B,EAC7B,SAAiB,EACjB,QAAgB;IAEhB,MAAM,GAAG,GAAG,SAAS,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC;IACrE,OAAO,IAAA,sBAAU,EAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAA,mBAAO,EAAC,SAAS,EAAE,GAAG,CAAC,CAAC;AACzD,CAAC;AAED;;;;GAIG;AACH,SAAgB,YAAY,CAAC,IAK5B;IACC,MAAM,OAAO,GAAG,IAAA,0BAAc,EAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAC/C,MAAM,IAAI,GAAG,IAAA,wBAAY,EAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;IACnD,MAAM,UAAU,GAAG,iBAAiB,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,EAAE,qCAAqC,CAAC,CAAC;IACzG,IAAA,mBAAS,EAAC,IAAA,mBAAO,EAAC,UAAU,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACpD,IAAA,uBAAa,EAAC,UAAU,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;IACxC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;AAC9B,CAAC;AAED;;;;;GAKG;AACI,KAAK,UAAU,UAAU,CAAC,aAOhC;IACC,YAAY,CAAC;QACX,MAAM,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,KAAK,IAAI,EAAE;QACnD,SAAS,EAAE,IAAA,mBAAO,EAAC,aAAa,CAAC,UAAU,CAAC;QAC5C,SAAS,EAAE,aAAa,CAAC,IAAI,CAAC,SAAS;QACvC,SAAS,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM;KAC1C,CAAC,CAAC;AACL,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,QAAQ;IACtB,IAAA,mCAAgB,EAAC;QACf,UAAU;YACR,OAAO;gBACL,aAAa,EAAE,qCAAqC;gBACpD,UAAU,EAAE,yBAAyB;gBACrC,OAAO,EAAE,WAAW;aACrB,CAAC;QACJ,CAAC;QACD,KAAK,CAAC,UAAU,CAAC,OAAO;YACtB,MAAM,UAAU,CAAC,OAAO,CAAC,CAAC;QAC5B,CAAC;KACF,CAAC,CAAC;AACL,CAAC;AAED,oEAAoE;AACpE,+DAA+D;AAC/D,qDAAqD;AACrD,yCAA6C;AAApC,2GAAA,cAAc,OAAA;AACvB,yCAA2C;AAAlC,yGAAA,YAAY,OAAA;AAUR,QAAA,SAAS,GAAG,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * prisma-effect-schema-generator
+ *
+ * Standalone Prisma generator that emits Effect Schema values for every
+ * model in your `schema.prisma`.
+ *
+ * Public API:
+ *   - {@link register} -- wire up the generator with `@prisma/generator-helper`.
+ *   - {@link runGenerator} -- programmatic entry (no Prisma required).
+ *   - {@link renderModule} -- render the TS source for a given DMMF.
+ *   - {@link resolveOptions} -- normalise user config.
+ *
+ * Most users will never touch this file directly. Add the generator to
+ * `schema.prisma` and run `prisma generate`.
+ */
+export { register, runGenerator, onGenerate, resolveOutputPath, } from "./generator.js";
+export { renderModule } from "./render.js";
+export { prismaFieldToBaseSchema, prismaFieldToEffectSchema, enumToSchema, isIncludeField, sortModels, } from "./mapper.js";
+export { resolveOptions, DEFAULTS } from "./config.js";
+export { shouldQuoteName, renderKey } from "./render.js";
+export type { DMMFDatamodelLike, DMMFEnumLike, DMMFFieldLike, DMMFModelLike, GeneratorOptionsConfig, ResolvedOptions, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,EACL,QAAQ,EACR,YAAY,EACZ,UAAU,EACV,iBAAiB,GAClB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EACL,uBAAuB,EACvB,yBAAyB,EACzB,YAAY,EACZ,cAAc,EACd,UAAU,GACX,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACzD,YAAY,EACV,iBAAiB,EACjB,YAAY,EACZ,aAAa,EACb,aAAa,EACb,sBAAsB,EACtB,eAAe,GAChB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * prisma-effect-schema-generator
+ *
+ * Standalone Prisma generator that emits Effect Schema values for every
+ * model in your `schema.prisma`.
+ *
+ * Public API:
+ *   - {@link register} -- wire up the generator with `@prisma/generator-helper`.
+ *   - {@link runGenerator} -- programmatic entry (no Prisma required).
+ *   - {@link renderModule} -- render the TS source for a given DMMF.
+ *   - {@link resolveOptions} -- normalise user config.
+ *
+ * Most users will never touch this file directly. Add the generator to
+ * `schema.prisma` and run `prisma generate`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderKey = exports.shouldQuoteName = exports.DEFAULTS = exports.resolveOptions = exports.sortModels = exports.isIncludeField = exports.enumToSchema = exports.prismaFieldToEffectSchema = exports.prismaFieldToBaseSchema = exports.renderModule = exports.resolveOutputPath = exports.onGenerate = exports.runGenerator = exports.register = void 0;
+const generator_js_1 = require("./generator.js");
+var generator_js_2 = require("./generator.js");
+Object.defineProperty(exports, "register", { enumerable: true, get: function () { return generator_js_2.register; } });
+Object.defineProperty(exports, "runGenerator", { enumerable: true, get: function () { return generator_js_2.runGenerator; } });
+Object.defineProperty(exports, "onGenerate", { enumerable: true, get: function () { return generator_js_2.onGenerate; } });
+Object.defineProperty(exports, "resolveOutputPath", { enumerable: true, get: function () { return generator_js_2.resolveOutputPath; } });
+var render_js_1 = require("./render.js");
+Object.defineProperty(exports, "renderModule", { enumerable: true, get: function () { return render_js_1.renderModule; } });
+var mapper_js_1 = require("./mapper.js");
+Object.defineProperty(exports, "prismaFieldToBaseSchema", { enumerable: true, get: function () { return mapper_js_1.prismaFieldToBaseSchema; } });
+Object.defineProperty(exports, "prismaFieldToEffectSchema", { enumerable: true, get: function () { return mapper_js_1.prismaFieldToEffectSchema; } });
+Object.defineProperty(exports, "enumToSchema", { enumerable: true, get: function () { return mapper_js_1.enumToSchema; } });
+Object.defineProperty(exports, "isIncludeField", { enumerable: true, get: function () { return mapper_js_1.isIncludeField; } });
+Object.defineProperty(exports, "sortModels", { enumerable: true, get: function () { return mapper_js_1.sortModels; } });
+var config_js_1 = require("./config.js");
+Object.defineProperty(exports, "resolveOptions", { enumerable: true, get: function () { return config_js_1.resolveOptions; } });
+Object.defineProperty(exports, "DEFAULTS", { enumerable: true, get: function () { return config_js_1.DEFAULTS; } });
+var render_js_2 = require("./render.js");
+Object.defineProperty(exports, "shouldQuoteName", { enumerable: true, get: function () { return render_js_2.shouldQuoteName; } });
+Object.defineProperty(exports, "renderKey", { enumerable: true, get: function () { return render_js_2.renderKey; } });
+// Auto-register when imported as the generator entry point.
+// We guard with a feature-detection on `process` so importing the
+// module from tests / Node doesn't crash on environments that lack it.
+if (typeof process !== "undefined" && process.env.PRISMA_GENERATOR_AUTO_REGISTER !== "0") {
+    try {
+        (0, generator_js_1.register)();
+    }
+    catch {
+        // No-op: registering requires `@prisma/generator-helper`'s
+        // `generatorHandler`, which only works under Prisma's spawn. When
+        // imported from a test / a build script we skip registration.
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAEH,iDAA0C;AAE1C,+CAKwB;AAJtB,wGAAA,QAAQ,OAAA;AACR,4GAAA,YAAY,OAAA;AACZ,0GAAA,UAAU,OAAA;AACV,iHAAA,iBAAiB,OAAA;AAEnB,yCAA2C;AAAlC,yGAAA,YAAY,OAAA;AACrB,yCAMqB;AALnB,oHAAA,uBAAuB,OAAA;AACvB,sHAAA,yBAAyB,OAAA;AACzB,yGAAA,YAAY,OAAA;AACZ,2GAAA,cAAc,OAAA;AACd,uGAAA,UAAU,OAAA;AAEZ,yCAAuD;AAA9C,2GAAA,cAAc,OAAA;AAAE,qGAAA,QAAQ,OAAA;AACjC,yCAAyD;AAAhD,4GAAA,eAAe,OAAA;AAAE,sGAAA,SAAS,OAAA;AAUnC,4DAA4D;AAC5D,kEAAkE;AAClE,uEAAuE;AACvE,IAAI,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,CAAC,GAAG,CAAC,8BAA8B,KAAK,GAAG,EAAE,CAAC;IACzF,IAAI,CAAC;QACH,IAAA,uBAAQ,GAAE,CAAC;IACb,CAAC;IAAC,MAAM,CAAC;QACP,2DAA2D;QAC3D,kEAAkE;QAClE,8DAA8D;IAChE,CAAC;AACH,CAAC"}

package/dist/mapper.d.ts

@@ -0,0 +1,55 @@
+import type { DMMFDatamodelLike, DMMFFieldLike, DMMFModelLike, ResolvedOptions } from "./types.js";
+/**
+ * Return the local binding for the Effect Schema namespace.
+ *
+ * Default is `Schema` -- which is what `effect` exports. If the user
+ * has chosen to import it under a different name we honour that
+ * throughout the file.
+ */
+export declare function localBinding(options: ResolvedOptions): string;
+/**
+ * Map a single Prisma scalar field to its Effect Schema expression,
+ * without list/optional wrappers.
+ *
+ * Returns the raw `Schema.<X>` identifier or a literal enum expression.
+ * Wrapping (lists + NullOr) is applied by {@link prismaFieldToEffectSchema}.
+ *
+ * For unknown / unsupported kinds we fall back to `Schema.Unknown` and
+ * emit a `// TODO` comment in the rendered output via
+ * {@link prismaFieldToEffectSchema}.
+ */
+export declare function prismaFieldToBaseSchema(field: DMMFFieldLike, datamodel: DMMFDatamodelLike, options: ResolvedOptions): {
+    expr: string;
+    unsupported: boolean;
+};
+/**
+ * Apply list + optional wrappers to a base schema expression and return
+ * the final Effect Schema expression for the field.
+ */
+export declare function prismaFieldToEffectSchema(field: DMMFFieldLike, datamodel: DMMFDatamodelLike, options: ResolvedOptions): {
+    expr: string;
+    unsupported: boolean;
+};
+/**
+ * Render an enum field as `Schema.Union(Schema.Literal("A"), Schema.Literal("B"))`.
+ *
+ * If the enum can't be found in the datamodel we emit
+ * `Schema.Literal("UNKNOWN")` as a sentinel so the generated file is still
+ * parseable; the user will get a clear runtime error.
+ */
+export declare function enumToSchema(enumName: string, datamodel: DMMFDatamodelLike, options?: ResolvedOptions): string;
+/**
+ * Decide whether a field is "safe" to include in the generated Struct.
+ *
+ * - Scalars: yes
+ * - Enums:   yes
+ * - Object (relation) fields: skipped (Prisma gives you the model directly)
+ * - Unsupported fields: included as `Schema.Unknown` so nothing breaks
+ */
+export declare function isIncludeField(field: DMMFFieldLike): boolean;
+/**
+ * Sort models so that the output is deterministic regardless of the order
+ * DMMF hands them to us in. Field order inside a model is preserved.
+ */
+export declare function sortModels(models: readonly DMMFModelLike[]): DMMFModelLike[];
+//# sourceMappingURL=mapper.d.ts.map

package/dist/mapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapper.d.ts","sourceRoot":"","sources":["../src/mapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,aAAa,EACb,aAAa,EACb,eAAe,EAChB,MAAM,YAAY,CAAC;AAEpB;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,eAAe,GAAG,MAAM,CAI7D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,aAAa,EACpB,SAAS,EAAE,iBAAiB,EAC5B,OAAO,EAAE,eAAe,GACvB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CAyCxC;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,aAAa,EACpB,SAAS,EAAE,iBAAiB,EAC5B,OAAO,EAAE,eAAe,GACvB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CAOxC;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,iBAAiB,EAC5B,OAAO,CAAC,EAAE,eAAe,GACxB,MAAM,CAiBR;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAE5D;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,GAAG,aAAa,EAAE,CAE5E"}

package/dist/mapper.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localBinding = localBinding;
+exports.prismaFieldToBaseSchema = prismaFieldToBaseSchema;
+exports.prismaFieldToEffectSchema = prismaFieldToEffectSchema;
+exports.enumToSchema = enumToSchema;
+exports.isIncludeField = isIncludeField;
+exports.sortModels = sortModels;
+/**
+ * Return the local binding for the Effect Schema namespace.
+ *
+ * Default is `Schema` -- which is what `effect` exports. If the user
+ * has chosen to import it under a different name we honour that
+ * throughout the file.
+ */
+function localBinding(options) {
+    return options.effectImportName === "Schema"
+        ? "Schema"
+        : options.effectImportName;
+}
+/**
+ * Map a single Prisma scalar field to its Effect Schema expression,
+ * without list/optional wrappers.
+ *
+ * Returns the raw `Schema.<X>` identifier or a literal enum expression.
+ * Wrapping (lists + NullOr) is applied by {@link prismaFieldToEffectSchema}.
+ *
+ * For unknown / unsupported kinds we fall back to `Schema.Unknown` and
+ * emit a `// TODO` comment in the rendered output via
+ * {@link prismaFieldToEffectSchema}.
+ */
+function prismaFieldToBaseSchema(field, datamodel, options) {
+    const b = localBinding(options);
+    // Enums first -- they don't have a fixed `type` like scalars do.
+    if (field.kind === "enum") {
+        return {
+            expr: enumToSchema(field.type, datamodel, options),
+            unsupported: false,
+        };
+    }
+    // "Unsupported" fields (e.g. Mongo `Unsupported("...")`) carry a
+    // declared `type` but the underlying DB can't represent it. We must
+    // short-circuit here, otherwise the type-switch below would resolve
+    // them to whatever their declared type maps to (often misleading).
+    if (field.kind === "unsupported") {
+        return { expr: `${b}.Unknown`, unsupported: true };
+    }
+    switch (field.type) {
+        case "String":
+            return { expr: `${b}.String`, unsupported: false };
+        case "Int":
+        case "Float":
+            return { expr: `${b}.Number`, unsupported: false };
+        case "BigInt":
+            return { expr: `${b}.${options.bigIntAs}`, unsupported: false };
+        case "Decimal":
+            return { expr: `${b}.${options.decimalAs}`, unsupported: false };
+        case "Boolean":
+            return { expr: `${b}.Boolean`, unsupported: false };
+        case "DateTime":
+            return { expr: `${b}.${options.dateAs}`, unsupported: false };
+        case "Json":
+            return { expr: `${b}.Unknown`, unsupported: false };
+        case "Bytes":
+            return { expr: `${b}.Uint8Array`, unsupported: false };
+        default:
+            // Unknown / future Prisma types land here.
+            return { expr: `${b}.Unknown`, unsupported: true };
+    }
+}
+/**
+ * Apply list + optional wrappers to a base schema expression and return
+ * the final Effect Schema expression for the field.
+ */
+function prismaFieldToEffectSchema(field, datamodel, options) {
+    const b = localBinding(options);
+    const base = prismaFieldToBaseSchema(field, datamodel, options);
+    let expr = base.expr;
+    if (field.isList)
+        expr = `${b}.Array(${expr})`;
+    if (!field.isRequired)
+        expr = `${b}.NullOr(${expr})`;
+    return { expr, unsupported: base.unsupported };
+}
+/**
+ * Render an enum field as `Schema.Union(Schema.Literal("A"), Schema.Literal("B"))`.
+ *
+ * If the enum can't be found in the datamodel we emit
+ * `Schema.Literal("UNKNOWN")` as a sentinel so the generated file is still
+ * parseable; the user will get a clear runtime error.
+ */
+function enumToSchema(enumName, datamodel, options) {
+    const b = localBinding(options ?? {
+        effectImport: "effect",
+        effectImportName: "Schema",
+        bigIntAs: "BigIntFromSelf",
+        decimalAs: "String",
+        dateAs: "DateFromSelf",
+        exportModelNames: true,
+        exportModelNameType: true,
+    });
+    const en = datamodel.enums.find((e) => e.name === enumName);
+    if (!en || en.values.length === 0) {
+        return `${b}.Literal("UNKNOWN")`;
+    }
+    const literals = en.values.map((v) => `${b}.Literal(${JSON.stringify(v.name)})`);
+    if (literals.length === 1)
+        return literals[0];
+    return `${b}.Union(${literals.join(", ")})`;
+}
+/**
+ * Decide whether a field is "safe" to include in the generated Struct.
+ *
+ * - Scalars: yes
+ * - Enums:   yes
+ * - Object (relation) fields: skipped (Prisma gives you the model directly)
+ * - Unsupported fields: included as `Schema.Unknown` so nothing breaks
+ */
+function isIncludeField(field) {
+    return field.kind === "scalar" || field.kind === "enum" || field.kind === "unsupported";
+}
+/**
+ * Sort models so that the output is deterministic regardless of the order
+ * DMMF hands them to us in. Field order inside a model is preserved.
+ */
+function sortModels(models) {
+    return [...models].sort((a, b) => a.name.localeCompare(b.name));
+}
+//# sourceMappingURL=mapper.js.map

package/dist/mapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapper.js","sourceRoot":"","sources":["../src/mapper.ts"],"names":[],"mappings":"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"}

package/dist/render.d.ts

@@ -0,0 +1,39 @@
+import type { DMMFDatamodelLike, DMMFModelLike, ResolvedOptions } from "./types.js";
+/**
+ * Decide whether a property key needs to be quoted.
+ *
+ * The bare minimum is "valid identifier that is not a reserved word".
+ * Anything else -- names with hyphens, spaces, leading digits -- must be
+ * quoted, otherwise the generated TypeScript won't parse.
+ *
+ * We accept Unicode letters/digits (per the ECMAScript spec for
+ * IdentifierStart/IdentifierPart) so non-ASCII names like `caf\u00e9`
+ * don't get quoted needlessly.
+ */
+export declare function shouldQuoteName(name: string): boolean;
+/**
+ * Render a property key, smart-quoting it only when necessary.
+ *
+ * Always emits a quoted string if the name isn't a valid identifier or
+ * collides with a reserved word; otherwise emits the bare identifier.
+ * This is the only sane default -- we don't expose a "force quote" knob
+ * because quoting bare identifiers actively hurts readability and
+ * prevents destructuring in user code.
+ */
+export declare function renderKey(name: string): string;
+/**
+ * Render a single model as a `Schema.Struct({ ... })` expression.
+ *
+ * Relation fields (kind === "object") are skipped entirely. Scalar
+ * fields are emitted in the order they appear in the DMMF.
+ */
+export declare function renderModel(model: DMMFModelLike, datamodel: DMMFDatamodelLike, options: ResolvedOptions): string;
+/**
+ * Render the entire generated module.
+ *
+ * The output is byte-stable for the same input: model order is sorted
+ * alphabetically, field order is preserved, and we always emit a
+ * trailing newline.
+ */
+export declare function renderModule(datamodel: DMMFDatamodelLike, options: ResolvedOptions): string;
+//# sourceMappingURL=render.d.ts.map

package/dist/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../src/render.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,iBAAiB,EACjB,aAAa,EACb,eAAe,EAChB,MAAM,YAAY,CAAC;AAmBpB;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGrD;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9C;AAeD;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,aAAa,EACpB,SAAS,EAAE,iBAAiB,EAC5B,OAAO,EAAE,eAAe,GACvB,MAAM,CAiCR;AAgCD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,SAAS,EAAE,iBAAiB,EAC5B,OAAO,EAAE,eAAe,GACvB,MAAM,CAoCR"}

package/dist/render.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldQuoteName = shouldQuoteName;
+exports.renderKey = renderKey;
+exports.renderModel = renderModel;
+exports.renderModule = renderModule;
+const mapper_js_1 = require("./mapper.js");
+const RESERVED_IDENTIFIERS = new Set([
+    // ECMAScript reserved words -- these are illegal as object property
+    // keys when unquoted, period.
+    "break", "case", "catch", "class", "const", "continue", "debugger",
+    "default", "delete", "do", "else", "enum", "export", "extends", "false",
+    "finally", "for", "function", "if", "import", "in", "instanceof", "new",
+    "null", "return", "super", "switch", "this", "throw", "true", "try",
+    "typeof", "var", "void", "while", "with", "yield",
+    // Strict-mode reserved.
+    "implements", "interface", "let", "package", "private", "protected",
+    "public", "static", "await",
+    // NOTE: TypeScript type-level keywords (`string`, `number`, `boolean`,
+    // `any`, `unknown`, `never`, `void`, `undefined`, `null`, ...) are NOT
+    // reserved as object property keys. `{ string: "hi" }` parses fine in
+    // TS 5+. Only the value-level reserved words above need quoting.
+]);
+/**
+ * Decide whether a property key needs to be quoted.
+ *
+ * The bare minimum is "valid identifier that is not a reserved word".
+ * Anything else -- names with hyphens, spaces, leading digits -- must be
+ * quoted, otherwise the generated TypeScript won't parse.
+ *
+ * We accept Unicode letters/digits (per the ECMAScript spec for
+ * IdentifierStart/IdentifierPart) so non-ASCII names like `caf\u00e9`
+ * don't get quoted needlessly.
+ */
+function shouldQuoteName(name) {
+    if (RESERVED_IDENTIFIERS.has(name))
+        return true;
+    return !/^[\p{L}_$][\p{L}\p{N}_$]*$/u.test(name);
+}
+/**
+ * Render a property key, smart-quoting it only when necessary.
+ *
+ * Always emits a quoted string if the name isn't a valid identifier or
+ * collides with a reserved word; otherwise emits the bare identifier.
+ * This is the only sane default -- we don't expose a "force quote" knob
+ * because quoting bare identifiers actively hurts readability and
+ * prevents destructuring in user code.
+ */
+function renderKey(name) {
+    return shouldQuoteName(name) ? JSON.stringify(name) : name;
+}
+/**
+ * The local binding for the Effect Schema namespace.
+ *
+ * Default is `Schema` -- which is what `effect` exports. If the user
+ * has chosen to import it under a different name we honour that
+ * throughout the file.
+ */
+function localBinding(options) {
+    return options.effectImportName === "Schema"
+        ? "Schema"
+        : options.effectImportName;
+}
+/**
+ * Render a single model as a `Schema.Struct({ ... })` expression.
+ *
+ * Relation fields (kind === "object") are skipped entirely. Scalar
+ * fields are emitted in the order they appear in the DMMF.
+ */
+function renderModel(model, datamodel, options) {
+    const lines = [];
+    const binding = localBinding(options);
+    const unsupportedComments = [];
+    lines.push(`export const ${model.name}Schema = ${binding}.Struct({`);
+    for (const field of model.fields) {
+        if (!(0, mapper_js_1.isIncludeField)(field))
+            continue;
+        const { expr, unsupported } = (0, mapper_js_1.prismaFieldToEffectSchema)(field, datamodel, options);
+        const key = renderKey(field.name);
+        lines.push(`  ${key}: ${expr},`);
+        if (unsupported && field.kind === "unsupported") {
+            unsupportedComments.push(`//   - ${field.name}: Prisma marks this field as "unsupported" -- typed as Schema.Unknown.`);
+        }
+    }
+    lines.push("})");
+    if (unsupportedComments.length > 0) {
+        lines.unshift(`// WARNING: ${model.name} contains unsupported fields:`);
+        for (const c of unsupportedComments)
+            lines.unshift(c);
+        lines.unshift("");
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+/**
+ * Render the helper exports at the bottom of the file:
+ *
+ *   export type ModelName = "Todo" | "Event";
+ *   export const ALL_MODEL_NAMES = ["Todo", "Event"] as const;
+ *
+ * These are guarded by `options.exportModelNames` /
+ * `options.exportModelNameType` so users can disable either piece.
+ */
+function renderModelHelpers(models, options) {
+    const lines = [];
+    if (options.exportModelNameType && models.length > 0) {
+        lines.push("export type ModelName =");
+        for (const m of models) {
+            lines.push(`  | ${JSON.stringify(m.name)}`);
+        }
+        lines.push("");
+    }
+    if (options.exportModelNames && models.length > 0) {
+        lines.push(`export const ALL_MODEL_NAMES = ${JSON.stringify(models.map((m) => m.name))} as const`, "");
+    }
+    return lines;
+}
+/**
+ * Render the entire generated module.
+ *
+ * The output is byte-stable for the same input: model order is sorted
+ * alphabetically, field order is preserved, and we always emit a
+ * trailing newline.
+ */
+function renderModule(datamodel, options) {
+    const lines = [];
+    lines.push(`// AUTO-GENERATED by prisma-effect-schema-generator -- do not edit.`, `// Regenerate via \`prisma generate\`.`, "");
+    if (datamodel.models.length === 0) {
+        lines.push(`// No models in your schema.prisma -- nothing to generate.`, `export const ALL_MODEL_NAMES = [] as const`, `export type ModelName = never`, "");
+        return lines.join("\n");
+    }
+    if (options.effectImportName === "Schema") {
+        lines.push(`import { Schema } from "${options.effectImport}"`, "");
+    }
+    else {
+        lines.push(`import { Schema as ${options.effectImportName} } from "${options.effectImport}"`, "");
+    }
+    const models = (0, mapper_js_1.sortModels)(datamodel.models);
+    for (const m of models) {
+        lines.push(renderModel(m, datamodel, options));
+    }
+    lines.push(...renderModelHelpers(models, options));
+    return lines.join("\n");
+}
+//# sourceMappingURL=render.js.map

package/dist/render.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.js","sourceRoot":"","sources":["../src/render.ts"],"names":[],"mappings":"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"}

package/dist/types.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Public configuration for the generator.
+ *
+ * Each option is read from the `generator` block in `schema.prisma`,
+ * e.g. `effectImport = "effect"` becomes `effectImport` here.
+ *
+ * Unknown options are ignored (Prisma only forwards strings).
+ */
+export interface GeneratorOptionsConfig {
+    /** Path the generated module is written to. */
+    readonly output?: string;
+    /** Module specifier for `Schema`. Defaults to `"effect"`. */
+    readonly effectImport?: string;
+    /** Local name to import `Schema` under. Defaults to `"Schema"`. */
+    readonly effectImportName?: string;
+    /** How `BigInt` Prisma fields map to Effect. Default `"BigIntFromSelf"`. */
+    readonly bigIntAs?: "BigInt" | "BigIntFromSelf";
+    /** How `Decimal` Prisma fields map to Effect. Default `"String"`. */
+    readonly decimalAs?: "String" | "Number";
+    /** How `DateTime` Prisma fields map to Effect. Default `"Date"`. */
+    readonly dateAs?: "Date" | "DateFromSelf";
+    /**
+     * Emit `ALL_MODEL_NAMES` and `ModelName` helpers. Default `true`.
+     * Set to `"false"` to disable.
+     */
+    readonly exportModelNames?: boolean | string;
+    /**
+     * Emit the `ModelName` TypeScript union type. Default `true`.
+     * Set to `"false"` to disable.
+     */
+    readonly exportModelNameType?: boolean | string;
+}
+/**
+ * Fully-resolved options (defaults applied) used internally by the renderer.
+ */
+export interface ResolvedOptions {
+    readonly effectImport: string;
+    readonly effectImportName: string;
+    readonly bigIntAs: "BigInt" | "BigIntFromSelf";
+    readonly decimalAs: "String" | "Number";
+    readonly dateAs: "Date" | "DateFromSelf";
+    readonly exportModelNames: boolean;
+    readonly exportModelNameType: boolean;
+}
+/**
+ * The shape of an `@prisma/dmmf` field that we care about.
+ *
+ * We type it minimally here so the renderer can be exercised against
+ * partial fixtures in tests without needing the full DMMF type.
+ */
+export interface DMMFFieldLike {
+    readonly kind: "scalar" | "object" | "enum" | "unsupported";
+    readonly name: string;
+    readonly type: string;
+    readonly isRequired: boolean;
+    readonly isList: boolean;
+    readonly isUnique?: boolean;
+    readonly isId?: boolean;
+    readonly hasDefaultValue?: boolean;
+    readonly dbName?: string | null;
+}
+export interface DMMFModelLike {
+    readonly name: string;
+    readonly dbName?: string | null;
+    readonly fields: readonly DMMFFieldLike[];
+}
+export interface DMMFEnumLike {
+    readonly name: string;
+    readonly values: readonly {
+        readonly name: string;
+    }[];
+}
+export interface DMMFDatamodelLike {
+    readonly models: readonly DMMFModelLike[];
+    readonly enums: readonly DMMFEnumLike[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,WAAW,sBAAsB;IACrC,+CAA+C;IAC/C,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,6DAA6D;IAC7D,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,mEAAmE;IACnE,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,4EAA4E;IAC5E,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,GAAG,gBAAgB,CAAC;IAChD,qEAAqE;IACrE,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IACzC,oEAAoE;IACpE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,cAAc,CAAC;IAC1C;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC7C;;;OAGG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;CACjD;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,gBAAgB,CAAC;IAC/C,QAAQ,CAAC,SAAS,EAAE,QAAQ,GAAG,QAAQ,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAAC;IACzC,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;CACvC;AAED;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,aAAa,CAAC;IAC5D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,CAAC;CAC3C;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,SAAS;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACvD;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,CAAC;IAC1C,QAAQ,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,CAAC;CACzC"}

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "prisma-effect-schema-generator",
+  "version": "0.1.0",
+  "description": "Prisma generator that emits Effect Schema values for every model — drop-in validation for your database rows.",
+  "keywords": [
+    "prisma",
+    "prisma-generator",
+    "effect",
+    "effect-schema",
+    "schema",
+    "validation",
+    "orm",
+    "typescript",
+    "dmmf"
+  ],
+  "license": "MIT",
+  "author": "Cyberistic",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Cyberistic/Prisma-Effect-Schema-Generator.git"
+  },
+  "homepage": "https://github.com/Cyberistic/Prisma-Effect-Schema-Generator#readme",
+  "bugs": {
+    "url": "https://github.com/Cyberistic/Prisma-Effect-Schema-Generator/issues"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build && npm test",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "lint": "echo 'no linter configured'"
+  },
+  "dependencies": {
+    "@prisma/generator-helper": "^7.0.0"
+  },
+  "peerDependencies": {
+    "@prisma/generator-helper": "^7.0.0",
+    "effect": "^3.0.0 || ^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "effect": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@prisma/generator-helper": "^7.8.0",
+    "@types/node": "^22.10.0",
+    "effect": "^3.21.0",
+    "prisma": "^7.8.0",
+    "typescript": "^5.4.5",
+    "vitest": "^2.1.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}