@tredy-ai/prisma-go-generator 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tredy AI, Inc.
+
+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/NOTICE

@@ -0,0 +1,34 @@
+prisma-go-generator
+Copyright (c) 2026 Tredy AI, Inc.
+
+This project adapts the design and implementation approach of two generators by
+Lexmata LLC, both released under the MIT License:
+
+  prisma-ent-generator   https://github.com/Lexmata/prisma-ent-generator
+  prisma-rust-generator  https://github.com/Lexmata/prisma-rust-generator
+
+Their copyright and permission notice follows.
+
+--------------------------------------------------------------------------------
+
+MIT License
+
+Copyright (c) 2026 Lexmata LLC
+
+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

@@ -1,3 +1,328 @@
-# Temporary Holding Version
+# prisma-go-generator
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A [Prisma](https://www.prisma.io/) generator that writes Go from your Prisma schema: a struct per model, a type per enum, and, if you ask for them, Prisma's query input types (`UserWhereInput`, `UserUncheckedCreateInput` and the rest).
+
+The output is plain data. It has no runtime and no query engine, so it works with whichever database library you already use.
+
+```prisma
+generator go {
+  provider = "prisma-go-generator"
+  output   = "../models"
+}
+```
+
+```go
+// User - A person who can sign in.
+type User struct {
+	Id        int32     `json:"id,omitempty" db:"id"` // primary key
+	Email     string    `json:"email" db:"email"`
+	Name      *string   `json:"name,omitempty" db:"name"`
+	Role      Role      `json:"role,omitempty" db:"role"`
+	CreatedAt time.Time `json:"createdAt,omitempty" db:"created_at"`
+
+	// Relations (not persisted, populate manually)
+	Posts []Post `json:"posts,omitempty" db:"-"`
+}
+```
+
+With no options set, the output is what [prisma2go](https://github.com/tredy-ai/prisma2go) writes. Every decision prisma2go made for you is an option here.
+
+## Status
+
+Pre-1.0: options and output may still change between minor versions. Tested against Prisma 7.10 and Go 1.27.
+
+## Requirements
+
+- Node.js 20.19 or later and Prisma 7.
+- `gofmt` on your `PATH` when `prisma generate` runs. The generator formats its output with it, so the files never change when you run `gofmt` yourself. Set `gofmt = "false"` to do without.
+- [enumer](https://github.com/dmarkham/enumer) on your `PATH` if you want `String`, JSON and SQL methods on integer enums. Without it the generator prints a warning and carries on. Under Go 1.27 use enumer v1.7.2 or later: v1.6.3 cannot load packages there and fails with `package "time" without types was imported`.
+- Go 1.18 or later to compile the query inputs, which use generics.
+
+## Install
+
+```bash
+pnpm add -D prisma @tredy-ai/prisma-go-generator
+go install github.com/dmarkham/enumer@latest   # optional
+```
+
+Add the generator block shown above to your schema, then run `pnpm prisma generate`.
+
+Prisma runs every generator block on each `prisma generate`. To run only some of them, name them: `prisma generate --generator client`.
+
+## Options
+
+Every option is a string, or a list of strings, in the generator block. `output` is Prisma's own option and is resolved relative to the schema file that declares the generator.
+
+| Option | Default | What it does |
+|---|---|---|
+| `output` | `./models` | Directory the Go files are written to. |
+| `package` | name of the output directory | Go package name. |
+| `emitSingle` | `"true"` | Write everything to one file, named by `fileName`. |
+| `emitPerFile` | `"false"` | Write one Go file per `.prisma` file. |
+| `emitPerModel` | `"false"` | Write one Go file per model, holding the struct and its inputs. Enums go to `enums.go`. |
+| `fileName` | `models.go` | File name for the single layout. |
+| `structTags` | `["json", "db"]` | Struct tags to write, in order. See [Struct tags](#struct-tags). |
+| `omitempty` | `["json"]` | Tags that get `,omitempty` on optional and defaulted columns. |
+| `types` | `[]` | Go type overrides. See [Type mapping](#type-mapping). |
+| `optionalType` | `pointer` | How an optional column is typed: `*T`, or a generic wrapper such as `database/sql.Null`. |
+| `enumType` | `int` | Go type behind enums: any integer type (`int`, `uint8`, ...) or `string`. |
+| `enumer` | `"true"` for integer enums | Run enumer for every enum after generating. |
+| `enumerArgs` | `["-json", "-sql", "-text", "-trimprefix={name}"]` | Arguments passed to enumer after `-type={name}`. |
+| `enumDirective` | `enumer -type={name}` plus `enumerArgs` | The `//go:generate` line above each enum. Empty for none. |
+| `initialisms` | `[]` | Words to write in capitals in Go names, such as `["ID", "URL"]`. |
+| `relations` | `"true"` | Include relation fields in model structs and inputs. |
+| `tableNameMethod` | `"false"` | Add `func (User) TableName() string` to every model. |
+| `inputs` | `[]` | Query input families to generate. See [Query inputs](#query-inputs). |
+| `gofmt` | `"true"` | Format the output with `gofmt`. |
+| `generateGoMod` | `"false"` | Write a `go.mod` into the output directory if there is none. |
+| `goModule` | | Module path for the generated `go.mod`. Required with `generateGoMod`. |
+| `goVersion` | version of the installed Go | `go` directive for the generated `go.mod`. |
+| `runGoGenerate` | `"false"` | Run `go generate` in the output directory as the last step. |
+
+Only one of the three `emit*` options can be `"true"`. An option name the generator does not know is an error, so a typo cannot be silently ignored.
+
+Prisma passes `env("NAME")` in a custom option through as the bare name `NAME`, so use literal values here.
+
+## Type mapping
+
+| Prisma | Go |
+|---|---|
+| `String` | `string` |
+| `Int` | `int32` |
+| `BigInt` | `int64` |
+| `Float` | `float64` |
+| `Boolean` | `bool` |
+| `DateTime` | `time.Time` |
+| `Json` | `json.RawMessage` |
+| `Bytes` | `[]byte` |
+| `Decimal` | `string` |
+| `@db.Uuid` | `uuid.UUID` from `github.com/google/uuid` |
+| `@db.Real` | `float32` |
+| an enum | the generated enum type |
+| `T?` | `*T` |
+| `T[]` | `[]T` |
+| a to-one relation | `*Model` |
+| a to-many relation | `[]Model` |
+
+A type Prisma adds later, or one this table does not know, becomes `json.RawMessage`.
+
+### Overriding a type
+
+`types` takes entries of the form `Prisma=Go`. The left side is a Prisma scalar (`Int`) or a native type written as in the schema (`db.Uuid`). The right side is a Go type: a builtin as is, anything else as its import path, a dot, and the type name.
+
+```prisma
+generator go {
+  provider = "prisma-go-generator"
+  output   = "../models"
+  types    = [
+    "Int=int",
+    "Json=map[string]any",
+    "Decimal=github.com/shopspring/decimal.Decimal",
+    "db.Uuid=uuid.UUID",                // the standard library package, Go 1.27 and later
+    "db.Timestamptz=github.com/jackc/pgx/v5/pgtype.Timestamptz",
+  ]
+}
+```
+
+The generator works out the import and the package name from the path: `github.com/gofrs/uuid/v5.UUID` is written as `uuid.UUID`. A qualified type may start with `*` or `[]`.
+
+For a column, the generator looks for a type in this order: your override for its native type, your override for its scalar, the built-in native mapping, the built-in scalar mapping.
+
+## Struct tags
+
+`structTags` lists the tags to write. Each entry is a tag key, optionally followed by a colon and a naming:
+
+| Naming | Value for a field `createdAt @map("created_at")` |
+|---|---|
+| `field` | `createdAt`, the Prisma field name. The default for every tag but `db`. |
+| `column` | `created_at`, the database column. The default for `db`. |
+| `snake` | `created_at` |
+| `camel` | `createdAt` |
+| `pascal` | `CreatedAt`, the Go field name |
+
+```prisma
+structTags = ["json:snake", "db", "yaml", "bson:column"]
+omitempty  = ["json", "yaml"]
+```
+
+A relation field gets `-` in tags that use the `column` naming, and its name with `,omitempty` everywhere else. Set `structTags = []` for no tags.
+
+## Enums
+
+By default an enum becomes an integer type with `iota` constants, and enumer supplies the methods:
+
+```go
+//go:generate enumer -type=Role -json -sql -text -trimprefix=Role
+type Role int
+
+const (
+	RoleAdmin Role = iota
+	RoleUser
+)
+```
+
+With `enumType = "string"` the constants hold the value stored in the database (the `@map` name if there is one), and nothing else needs to run:
+
+```go
+type Role string
+
+const (
+	RoleAdmin Role = "ADMIN"
+	RoleUser  Role = "USER"
+)
+```
+
+The generator's own enumer run and a later `go generate` write identical files, so you can use either or both.
+
+To use a tool other than enumer, turn enumer off and set the directive: `enumer = "false"`, `enumDirective = "stringer -type={name}"`.
+
+## Query inputs
+
+`inputs` turns on Prisma's query input types as Go structs. They carry JSON tags with Prisma's field and operator names, so a value marshals to Prisma-style JSON. They are modelled on Prisma's client inputs but are not a drop-in for them: see [Differences from Prisma's inputs](#differences-from-prismas-inputs).
+
+| Family | Types generated per model |
+|---|---|
+| `where` | `UserWhereInput`, `UserRelationFilter`, `UserListRelationFilter` |
+| `whereUnique` | `UserWhereUniqueInput` |
+| `orderBy` | `UserOrderByWithRelationInput` |
+| `create` | `UserUncheckedCreateInput` |
+| `update` | `UserUncheckedUpdateInput` |
+| `select` | `UserSelect` |
+| `include` | `UserInclude` |
+
+Use `inputs = "all"` for every family.
+
+```go
+where := store.UserWhereInput{
+	Email: &store.StringFilter{Contains: new("@example.com"), Mode: store.QueryModeInsensitive},
+	Role:  &store.Filter[store.Role]{In: []store.Role{store.RoleAdmin, store.RoleMember}},
+	Orders: &store.OrderListRelationFilter{
+		Some: &store.OrderWhereInput{TotalCents: &store.RangeFilter[int]{Gte: new(10_000)}},
+	},
+}
+```
+
+`new` with a value, as used above, needs Go 1.26. On earlier versions take the address of a variable instead.
+
+The filters are generic over the column's Go type, so they follow your `types` overrides: `Filter[T]` (equality), `RangeFilter[T]` (adds `lt`, `lte`, `gt`, `gte`), `StringFilter` (adds `contains`, `startsWith`, `endsWith`, `mode`), `ListFilter[T]` for scalar lists, and a `Nullable` variant of each with `IsNull`. Updates use `FieldUpdate[T]`, `NumericFieldUpdate[T]` (`increment`, `decrement`, `multiply`, `divide`), `ListFieldUpdate[T]` and their `Nullable` variants.
+
+### Differences from Prisma's inputs
+
+- Create and update inputs are the `Unchecked` forms, which take foreign keys directly. Nested relation writes (`create`, `connect`, `connectOrCreate` and `upsert` inside a create or update) are not generated.
+- Aggregate and group-by inputs are not generated.
+- A nullable filter has `isNull`. Prisma writes that as `equals: null`, which a Go pointer cannot tell apart from "not set".
+- `WhereUniqueInput` lists the columns of a composite key or unique group as separate fields. Prisma nests them in one compound field.
+- Order-by inputs cover columns and to-one relations, not counts of to-many relations.
+- A nil slice and an empty slice both drop out of the JSON, so `in: []` cannot be expressed.
+
+## Layouts
+
+| Layout | Files |
+|---|---|
+| `emitSingle` | `models.go` with enums, models and inputs. |
+| `emitPerFile` | `users.prisma` becomes `users.go`, holding that file's enums, models and inputs. Shared input types go to `inputs.go`. |
+| `emitPerModel` | `user.go` per model with its struct and inputs, `enums.go`, and `inputs.go` for the shared input types. |
+
+On each run the generator deletes the Go files it wrote earlier and no longer writes, such as the file of a model you removed. It recognises its own files by their first line and leaves every other file alone. With `enumer` on, it also deletes enumer output for enums that no longer exist.
+
+A file name that the go tool would read as a build constraint gets `_gen` appended: a model called `UserWindows` is written to `user_windows_gen.go`.
+
+## Moving from prisma2go
+
+Add the generator block, then delete the DMMF script, the `prisma2go generate` step and `.prisma2go.yaml`.
+
+| `.prisma2go.yaml` | Generator block |
+|---|---|
+| `output: gomodels/models.go` | `output = "../gomodels"` (relative to the schema file) and `fileName = "models.go"` |
+| `package: prisma` | `package = "prisma"` |
+| `json_tags: false` | `structTags = ["db"]` |
+| `db_tags: false` | `structTags = ["json"]` |
+| `json_omitempty: false` | `omitempty = []` |
+| `uuid_package: ""` | `types = ["db.Uuid=string"]` |
+| `decimal_package: "github.com/shopspring/decimal"` | `types = ["Decimal=github.com/shopspring/decimal.Decimal"]` |
+| `no_enumer: true` | `enumer = "false"` |
+
+The generated file is then identical to prisma2go's, apart from the name in its first line.
+
+### Behaviour kept from prisma2go
+
+These are unchanged so that existing output does not move. Each can be worked around with an option.
+
+- A `@@unique` group is listed twice in the comment above a model, once from each place Prisma reports it.
+- Enum constants are the enum name followed by the value in Pascal case, so `FDLStatus.FDL_STATUS_DRAFT` becomes `FDLStatusFdlStatusDraft`.
+- An integer enum's first value is zero, and `omitempty` drops a zero from JSON. A defaulted enum column holding its first value is therefore left out when marshalled. Use `enumType = "string"` or `omitempty = []` if that matters to you.
+- Names are not rewritten to Go initialisms unless you list them: `userId` becomes `UserId`, or `UserID` with `initialisms = ["ID"]`.
+- The first line of the file is directly above the package clause, so Go reads it as the package comment.
+
+One thing differs: when the generated code does not parse, prisma2go wrote it unformatted and warned. This generator stops with gofmt's error instead.
+
+## Examples
+
+Both examples are complete projects with their generated Go committed, and each has an `example_test.go` that uses the output.
+
+- [`examples/basic`](examples/basic): one schema file, every option at its default.
+- [`examples/crud-inputs`](examples/crud-inputs): a multi-file schema, one Go file per model, string enums and query inputs.
+
+## Development
+
+```bash
+task install   # pnpm install
+task test      # unit tests, then a real `prisma generate` over test/e2e/schema
+task ci        # everything CI runs
+task --list
+```
+
+`task ci` needs Go 1.27 or later. It builds its own enumer into `.bin/`, at the version pinned in `Taskfile.yml`, so the examples do not depend on the enumer you have installed. It typechecks, runs the tests, compiles and vets the Go generated from the test schema, regenerates the examples, and fails if they differ from what is committed.
+
+The tests are in three layers:
+
+| Layer | Where | What it checks |
+|---|---|---|
+| Unit | `test/*.test.ts` | Naming, type mapping, option parsing, rendering and layouts, against small hand-built schemas. The prisma2go test cases are carried over. |
+| End to end | `test/e2e.test.ts` | Runs the Prisma CLI over `test/e2e/schema` with four generator blocks and compares each file with `test/e2e/expected`. `task test:update` rewrites the expected files. |
+| Go | `task test:go`, `task examples` | Builds and vets the generated code, and runs the examples' tests. |
+
+## Releasing
+
+Releases are cut by CI from commit messages. Nobody edits a version by hand.
+
+1. Open a pull request against `main`. `ci.yml` runs the checks.
+2. Squash-merge it with a [Conventional Commits](https://www.conventionalcommits.org/) message. That message decides the release:
+
+   | Commit message | Release |
+   |---|---|
+   | `fix:`, `perf:`, `hotfix:`, `patch:` | patch |
+   | `feat:` | minor |
+   | `feat!:`, `fix!:`, or a `BREAKING CHANGE:` footer | major (minor while the version is below 1.0.0) |
+   | `docs:`, `chore:`, `ci:`, `test:`, `refactor:`, anything else | none |
+
+3. `release.yml` runs the checks again on `main`, then works out the next version from every commit since the last `vX.Y.Z` tag, taking the largest bump.
+4. It publishes `@tredy-ai/prisma-go-generator` to npm with that version and the `latest` tag, then creates the `vX.Y.Z` tag and a GitHub release with generated notes.
+
+The same version is also published to GitHub Packages. npmjs.com is the public home; the copy is for setups whose `.npmrc` sends the whole `@tredy-ai` scope to `npm.pkg.github.com`, where an npmjs-only package would not be found.
+
+Put `[ci skip]` in the commit message to merge without starting the release workflow at all. GitHub does the skipping, and a commit marked that way is never counted towards a later release either.
+
+The version is kept in git tags. `package.json` says `0.0.0` in the repository and is stamped with the real version when the package is published, because CI cannot commit to `main`.
+
+A failed release can be re-run: publishing is skipped when the version is already on npm, and tagging when the release already exists.
+
+### One-time setup
+
+- **npm.** The workflow publishes by [trusted publishing](https://docs.npmjs.com/trusted-publishers/), which needs the package to exist first. For the first release, add an npm access token that may publish to the `@tredy-ai` scope as the repository secret `NPM_TOKEN`. After that release, add a trusted publisher to the package on npmjs.com (organisation `tredy-ai`, repository `prisma-go-generator`, workflow `release.yml`) and delete the secret.
+- **GitHub.** The repository has to be public for npm to attach provenance.
+
+## Acknowledgements
+
+This project stands on two generators by [Lexmata](https://github.com/Lexmata):
+
+- [prisma-ent-generator](https://github.com/Lexmata/prisma-ent-generator) is the inspiration for this generator and the source of how it is built: a TypeScript generator on `@prisma/generator-helper` that reads Prisma's DMMF and writes Go source, with its mapping, field and file-writing steps kept apart and tested one by one.
+- [prisma-rust-generator](https://github.com/Lexmata/prisma-rust-generator) is the source of the query input surface (which input types exist for a model and what goes in each), the three output layouts, mapping declarations back to their `.prisma` files, and pruning stale output by its header line.
+
+Both are MIT licensed; see [NOTICE](NOTICE).
+
+The mapping from Prisma to Go, the naming rules and the default struct tags come from [prisma2go](https://github.com/tredy-ai/prisma2go).
+
+## License
+
+MIT. See [LICENSE](LICENSE).

package/bin/prisma-go-generator.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/bin.js';

package/dist/bin.js

@@ -0,0 +1,7 @@
+// @prisma/generator-helper is CommonJS and Node cannot see its named exports from an ES module.
+import helper from '@prisma/generator-helper';
+import { generate } from './generator.js';
+helper.generatorHandler({
+    onManifest: () => ({ prettyName: 'Prisma Go Generator', defaultOutput: './models' }),
+    onGenerate: async (options) => generate(options),
+});

package/dist/config.js

@@ -0,0 +1,141 @@
+import { basename } from 'node:path';
+export const NAMINGS = ['field', 'column', 'snake', 'camel', 'pascal'];
+export const INPUT_FAMILIES = ['where', 'whereUnique', 'orderBy', 'create', 'update', 'select', 'include'];
+export const PRISMA_SCALARS = ['String', 'Int', 'BigInt', 'Float', 'Boolean', 'DateTime', 'Json', 'Bytes', 'Decimal'];
+const DEFAULT_ENUMER_ARGS = ['-json', '-sql', '-text', '-trimprefix={name}'];
+const INTEGER_TYPES = ['int', 'int8', 'int16', 'int32', 'int64', 'uint', 'uint8', 'uint16', 'uint32', 'uint64'];
+const LAYOUT_FLAGS = { emitSingle: 'single', emitPerFile: 'perFile', emitPerModel: 'perModel' };
+const OPTIONS = [
+    'emitSingle',
+    'emitPerFile',
+    'emitPerModel',
+    'fileName',
+    'package',
+    'structTags',
+    'omitempty',
+    'types',
+    'optionalType',
+    'enumType',
+    'enumDirective',
+    'enumer',
+    'enumerArgs',
+    'runGoGenerate',
+    'initialisms',
+    'relations',
+    'tableNameMethod',
+    'gofmt',
+    'inputs',
+    'generateGoMod',
+    'goModule',
+    'goVersion',
+];
+const IDENT = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function fail(message) {
+    return new Error(`prisma-go-generator: ${message}`);
+}
+export function parseConfig(generator) {
+    const raw = generator.config;
+    for (const key of Object.keys(raw)) {
+        if (!OPTIONS.includes(key))
+            throw fail(`unknown option "${key}". Known options: output, ${OPTIONS.join(', ')}`);
+    }
+    const str = (key, fallback) => {
+        const value = raw[key];
+        if (value === undefined)
+            return fallback;
+        if (Array.isArray(value))
+            throw fail(`${key} must be a single string`);
+        return value;
+    };
+    const bool = (key, fallback) => {
+        const value = str(key, String(fallback));
+        if (value !== 'true' && value !== 'false')
+            throw fail(`${key} must be "true" or "false", got "${value}"`);
+        return value === 'true';
+    };
+    const list = (key, fallback) => {
+        const value = raw[key];
+        if (value === undefined)
+            return fallback;
+        return Array.isArray(value) ? value : [value];
+    };
+    const goFile = (key, fallback) => {
+        const value = str(key, fallback);
+        if (!/^[^/\\]+\.go$/.test(value))
+            throw fail(`${key} must be a .go file name without a directory, got "${value}"`);
+        return value;
+    };
+    const dir = generator.output?.value;
+    if (!dir)
+        throw fail('no output directory');
+    const pkg = str('package', basename(dir));
+    if (!IDENT.test(pkg)) {
+        throw fail(`"${pkg}" is not a valid Go package name; set package = "..." in the generator block`);
+    }
+    const structTags = list('structTags', ['json', 'db']).map((entry) => {
+        const [key = '', naming = key === 'db' ? 'column' : 'field', ...rest] = entry.split(':');
+        if (!IDENT.test(key) || rest.length > 0)
+            throw fail(`structTags entry "${entry}" must look like "json" or "json:snake"`);
+        if (!NAMINGS.includes(naming)) {
+            throw fail(`structTags entry "${entry}": naming must be one of ${NAMINGS.join(', ')}`);
+        }
+        return { key, naming: naming };
+    });
+    const types = {};
+    for (const entry of list('types', [])) {
+        const eq = entry.indexOf('=');
+        const key = entry.slice(0, eq);
+        const goType = entry.slice(eq + 1);
+        if (eq < 1 || goType === '')
+            throw fail(`types entry "${entry}" must look like Prisma=Go, for example "Int=int" or "db.Uuid=string"`);
+        if (!PRISMA_SCALARS.includes(key) && !/^db\.\w+$/.test(key)) {
+            throw fail(`types entry "${entry}": "${key}" is neither a Prisma scalar (${PRISMA_SCALARS.join(', ')}) nor a native type such as db.Uuid`);
+        }
+        types[key] = goType;
+    }
+    const enumType = str('enumType', 'int');
+    const integerEnums = INTEGER_TYPES.includes(enumType);
+    if (!integerEnums && enumType !== 'string')
+        throw fail(`enumType must be "string" or one of ${INTEGER_TYPES.join(', ')}, got "${enumType}"`);
+    const enumer = bool('enumer', integerEnums);
+    if (enumer && !integerEnums)
+        throw fail('enumer = "true" needs an integer enumType: enumer only handles integer enums');
+    const enumerArgs = list('enumerArgs', DEFAULT_ENUMER_ARGS);
+    const layouts = Object.keys(LAYOUT_FLAGS).filter((flag) => bool(flag, false));
+    if (layouts.length > 1)
+        throw fail(`${layouts.join(' and ')} are mutually exclusive; set only one to "true"`);
+    const requested = list('inputs', []);
+    const inputs = requested.includes('all') ? [...INPUT_FAMILIES] : requested;
+    for (const family of inputs) {
+        if (!INPUT_FAMILIES.includes(family)) {
+            throw fail(`inputs entry "${family}" must be "all" or one of ${INPUT_FAMILIES.join(', ')}`);
+        }
+    }
+    const generateGoMod = bool('generateGoMod', false);
+    const goModule = str('goModule', '');
+    if (generateGoMod && goModule === '')
+        throw fail('generateGoMod = "true" needs goModule = "<module path>"');
+    return {
+        dir,
+        layout: layouts[0] ? LAYOUT_FLAGS[layouts[0]] : 'single',
+        fileName: goFile('fileName', 'models.go'),
+        package: pkg,
+        structTags,
+        omitempty: new Set(list('omitempty', ['json'])),
+        types,
+        optionalType: str('optionalType', 'pointer'),
+        enumType,
+        enumDirective: str('enumDirective', integerEnums ? ['enumer -type={name}', ...enumerArgs].join(' ') : ''),
+        enumer,
+        enumerArgs,
+        runGoGenerate: bool('runGoGenerate', false),
+        initialisms: new Set(list('initialisms', []).map((s) => s.toUpperCase())),
+        relations: bool('relations', true),
+        tableNameMethod: bool('tableNameMethod', false),
+        gofmt: bool('gofmt', true),
+        inputs: inputs,
+        generateGoMod,
+        goModule,
+        goVersion: str('goVersion', ''),
+    };
+}

package/dist/generator.js

@@ -0,0 +1,122 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { basename, extname, join } from 'node:path';
+import { parseConfig } from './config.js';
+import { HEADER, fileFor, generateFiles } from './layout.js';
+import { toPascalCase } from './naming.js';
+const fail = (message) => new Error(`prisma-go-generator: ${message}`);
+// Prisma reads the generator's stderr as its RPC channel, so messages for the user go to stdout.
+const warn = (message) => console.log(`prisma-go-generator: warning: ${message}`);
+function prismaFiles(path) {
+    if (statSync(path).isFile())
+        return [path];
+    return readdirSync(path, { withFileTypes: true })
+        .flatMap((entry) => {
+        const full = join(path, entry.name);
+        if (entry.isDirectory())
+            return prismaFiles(full);
+        return entry.isFile() && entry.name.endsWith('.prisma') ? [full] : [];
+    })
+        .sort();
+}
+/**
+ * Maps every model and enum to the name of the .prisma file that declares it. DMMF does not carry
+ * this, so the schema files are scanned for their `model X {` and `enum X {` lines.
+ */
+export function declarationFiles(schemaPath) {
+    const sources = new Map();
+    for (const file of prismaFiles(schemaPath)) {
+        const stem = basename(file, extname(file));
+        for (const match of readFileSync(file, 'utf8').matchAll(/^[ \t]*(?:model|enum|view)\s+(\w+)\s*\{/gm)) {
+            sources.set(match[1] ?? '', stem);
+        }
+    }
+    return sources;
+}
+function gofmt(source, fileName) {
+    const result = spawnSync('gofmt', { input: source, encoding: 'utf8', maxBuffer: Infinity });
+    if (result.error) {
+        throw fail(`could not run gofmt (${result.error.message}). Install Go, or set gofmt = "false" to write unformatted code.`);
+    }
+    if (result.status !== 0)
+        throw fail(`gofmt rejected ${fileName}:\n${result.stderr}`);
+    return result.stdout;
+}
+const firstLine = (path) => readFileSync(path, 'utf8').split('\n', 1)[0] ?? '';
+/**
+ * Deletes what an earlier run wrote and this run did not: files carrying this generator's header,
+ * and enumer output for enums that no longer exist. Anything else in the directory is left alone.
+ */
+function prune(dir, written, enumerFiles) {
+    for (const name of readdirSync(dir)) {
+        if (!name.endsWith('.go') || written.has(name))
+            continue;
+        const path = join(dir, name);
+        const head = firstLine(path);
+        const staleEnumer = enumerFiles !== null && name.endsWith('_enumer.go') && !enumerFiles.has(name) && head.startsWith('// Code generated by "enumer');
+        if (head === HEADER || staleEnumer)
+            rmSync(path);
+    }
+}
+function writeGoMod(cfg) {
+    const path = join(cfg.dir, 'go.mod');
+    // go.mod belongs to the user once it exists: `go mod tidy` adds their requirements to it.
+    if (existsSync(path))
+        return;
+    let version = cfg.goVersion;
+    if (version === '') {
+        const result = spawnSync('go', ['env', 'GOVERSION'], { encoding: 'utf8' });
+        version = /^go(\d+\.\d+)/.exec(result.stdout ?? '')?.[1] ?? '';
+        if (version === '')
+            throw fail('generateGoMod could not ask `go env GOVERSION` for a Go version; set goVersion = "1.xx"');
+    }
+    writeFileSync(path, `module ${cfg.goModule}\n\ngo ${version}\n`);
+}
+const enumerOutput = (goName) => `${goName.toLowerCase()}_enumer.go`;
+function runEnumer(cfg, enums) {
+    for (const [goName, file] of enums) {
+        const args = [`-type=${goName}`, ...cfg.enumerArgs.map((arg) => arg.replaceAll('{name}', goName))];
+        const output = enumerOutput(goName);
+        // Naming the source file keeps this working in a directory that is not inside a Go module.
+        const result = spawnSync('enumer', [...args, `-output=${output}`, file], { cwd: cfg.dir, encoding: 'utf8' });
+        if (result.error) {
+            warn('enumer is not on PATH, so no enum methods were generated. Install it with `go install github.com/dmarkham/enumer@latest`, or set enumer = "false".');
+            return;
+        }
+        if (result.status !== 0) {
+            warn(`enumer failed for ${goName}:\n${result.stderr}${result.stdout}`);
+            continue;
+        }
+        // enumer records its command line in the file's first line. Write the line the go:generate
+        // directive would produce, so this run and a later `go generate` leave identical files.
+        const path = join(cfg.dir, output);
+        const lines = readFileSync(path, 'utf8').split('\n');
+        if (lines[0]?.startsWith('// Code generated by "enumer ')) {
+            lines[0] = `// Code generated by "enumer ${args.join(' ')}"; DO NOT EDIT.`;
+            writeFileSync(path, lines.join('\n'));
+        }
+    }
+}
+export function generate(options) {
+    const cfg = parseConfig(options.generator);
+    const { datamodel } = options.dmmf;
+    const sources = cfg.layout === 'perFile' ? declarationFiles(options.schemaPath) : new Map();
+    const files = generateFiles(datamodel, cfg, sources);
+    mkdirSync(cfg.dir, { recursive: true });
+    for (const [name, source] of files) {
+        writeFileSync(join(cfg.dir, name), cfg.gofmt ? gofmt(source, name) : source);
+    }
+    const enums = datamodel.enums.map((e) => [toPascalCase(e.name, cfg.initialisms), fileFor('enum', e.name, cfg, sources)]);
+    prune(cfg.dir, new Set(files.keys()), cfg.enumer ? new Set(enums.map(([goName]) => enumerOutput(goName))) : null);
+    if (cfg.generateGoMod)
+        writeGoMod(cfg);
+    if (cfg.enumer)
+        runEnumer(cfg, enums);
+    if (cfg.runGoGenerate) {
+        const result = spawnSync('go', ['generate', '.'], { cwd: cfg.dir, encoding: 'utf8' });
+        if (result.error)
+            throw fail(`runGoGenerate could not run go (${result.error.message})`);
+        if (result.status !== 0)
+            throw fail(`go generate failed:\n${result.stderr}${result.stdout}`);
+    }
+}

package/dist/inputs.js

@@ -0,0 +1,222 @@
+import { INPUT_FAMILIES } from './config.js';
+import { toPascalCase } from './naming.js';
+import { baseType } from './types.js';
+const optional = (name) => `${name},omitempty`;
+function struct(doc, name, fields) {
+    const taken = new Set();
+    for (const [goName] of fields) {
+        if (taken.has(goName))
+            throw new Error(`prisma-go-generator: ${name} would have two fields named ${goName}`);
+        taken.add(goName);
+    }
+    return [`// ${doc}`, `type ${name} struct {`, ...fields.map(([n, type, tag]) => `\t${n} ${type} \`json:"${tag}"\``), '}'].join('\n');
+}
+function stringEnum(doc, name, values) {
+    const constants = values.map((v) => `\t${name}${toPascalCase(v)} ${name} = "${v}"`);
+    return [`// ${doc}`, `type ${name} string`, '', 'const (', ...constants, ')'].join('\n');
+}
+function filter(doc, name, t, kind) {
+    const self = name.replace('[T any]', '[T]');
+    const fields = [
+        ['Equals', `*${t}`, optional('equals')],
+        ['In', `[]${t}`, optional('in')],
+        ['NotIn', `[]${t}`, optional('notIn')],
+    ];
+    if (kind.nullable)
+        fields.push(['IsNull', '*bool', optional('isNull')]);
+    if (kind.range) {
+        for (const op of ['Lt', 'Lte', 'Gt', 'Gte'])
+            fields.push([op, `*${t}`, optional(op.toLowerCase())]);
+    }
+    if (kind.string) {
+        fields.push(['Contains', '*string', optional('contains')]);
+        fields.push(['StartsWith', '*string', optional('startsWith')]);
+        fields.push(['EndsWith', '*string', optional('endsWith')]);
+        fields.push(['Mode', 'QueryMode', optional('mode')]);
+    }
+    fields.push(['Not', `*${self}`, optional('not')]);
+    return struct(doc, name, fields);
+}
+function numericUpdate(doc, name, set) {
+    const ops = ['Increment', 'Decrement', 'Multiply', 'Divide'].map((op) => [op, '*T', optional(op.toLowerCase())]);
+    return struct(doc, name, [['Set', set, optional('set')], ...ops]);
+}
+/** Types shared by every model, per input family: [Go type name, declaration]. */
+const SHARED = {
+    where: [
+        ['QueryMode', stringEnum('QueryMode is the case sensitivity of a string filter.', 'QueryMode', ['default', 'insensitive'])],
+        ['Filter', filter('Filter matches a column of Go type T by equality. Every operator that is set must hold.', 'Filter[T any]', 'T', {})],
+        ['NullableFilter', filter('NullableFilter is Filter for a nullable column.', 'NullableFilter[T any]', 'T', { nullable: true })],
+        ['RangeFilter', filter('RangeFilter is Filter plus the ordering operators.', 'RangeFilter[T any]', 'T', { range: true })],
+        [
+            'NullableRangeFilter',
+            filter('NullableRangeFilter is RangeFilter for a nullable column.', 'NullableRangeFilter[T any]', 'T', { range: true, nullable: true }),
+        ],
+        ['StringFilter', filter('StringFilter is RangeFilter[string] plus the substring operators.', 'StringFilter', 'string', { range: true, string: true })],
+        [
+            'StringNullableFilter',
+            filter('StringNullableFilter is StringFilter for a nullable column.', 'StringNullableFilter', 'string', {
+                range: true,
+                string: true,
+                nullable: true,
+            }),
+        ],
+        [
+            'ListFilter',
+            struct('ListFilter matches a scalar list column.', 'ListFilter[T any]', [
+                ['Equals', '[]T', optional('equals')],
+                ['Has', '*T', optional('has')],
+                ['HasEvery', '[]T', optional('hasEvery')],
+                ['HasSome', '[]T', optional('hasSome')],
+                ['IsEmpty', '*bool', optional('isEmpty')],
+            ]),
+        ],
+    ],
+    orderBy: [['SortOrder', stringEnum('SortOrder is the direction of an order-by clause.', 'SortOrder', ['asc', 'desc'])]],
+    update: [
+        ['FieldUpdate', struct('FieldUpdate sets a column of Go type T.', 'FieldUpdate[T any]', [['Set', 'T', 'set']])],
+        [
+            'NullableFieldUpdate',
+            struct('NullableFieldUpdate sets a nullable column. A nil Set stores NULL.', 'NullableFieldUpdate[T any]', [['Set', '*T', 'set']]),
+        ],
+        [
+            'NumericFieldUpdate',
+            numericUpdate('NumericFieldUpdate sets a numeric column or changes it in place. Set one operation.', 'NumericFieldUpdate[T any]', '*T'),
+        ],
+        [
+            'NullableNumericFieldUpdate',
+            numericUpdate('NullableNumericFieldUpdate is NumericFieldUpdate for a nullable column. Set points at the new\n// value; a pointer to a nil *T stores NULL.', 'NullableNumericFieldUpdate[T any]', '**T'),
+        ],
+        [
+            'ListFieldUpdate',
+            struct('ListFieldUpdate replaces a scalar list column or appends to it.', 'ListFieldUpdate[T any]', [
+                ['Set', '[]T', optional('set')],
+                ['Push', '[]T', optional('push')],
+            ]),
+        ],
+    ],
+};
+const selected = (cfg) => INPUT_FAMILIES.filter((family) => cfg.inputs.includes(family));
+/** Declarations every model's inputs depend on. */
+export function sharedInputs(cfg) {
+    return selected(cfg).flatMap((family) => (SHARED[family] ?? []).map(([, code]) => code));
+}
+const ORDERED = new Set(['Int', 'BigInt', 'Float', 'Decimal', 'DateTime']);
+const NUMERIC = new Set(['Int', 'BigInt', 'Float', 'Decimal']);
+function whereFilter(field, t) {
+    if (field.isList)
+        return `ListFilter[${t}]`;
+    const nullable = !field.isRequired;
+    const isText = field.kind === 'scalar' && field.type === 'String' && field.nativeType?.[0] !== 'Uuid';
+    if (isText && t === 'string')
+        return nullable ? 'StringNullableFilter' : 'StringFilter';
+    const range = isText || (field.kind === 'scalar' && ORDERED.has(field.type));
+    return `${nullable ? 'Nullable' : ''}${range ? 'Range' : ''}Filter[${t}]`;
+}
+function updateOperation(field, t) {
+    if (field.isList)
+        return `ListFieldUpdate[${t}]`;
+    const numeric = field.kind === 'scalar' && NUMERIC.has(field.type);
+    return `${field.isRequired ? '' : 'Nullable'}${numeric ? 'Numeric' : ''}FieldUpdate[${t}]`;
+}
+function uniqueColumns(m) {
+    const names = new Set(m.primaryKey?.fields ?? []);
+    for (const group of m.uniqueFields ?? [])
+        group.forEach((name) => names.add(name));
+    for (const index of m.uniqueIndexes ?? [])
+        index.fields.forEach((name) => names.add(name));
+    for (const field of m.fields)
+        if (field.isId || field.isUnique)
+            names.add(field.name);
+    return names;
+}
+/** Go type names modelInputs declares for a model. */
+export function modelInputNames(m, cfg) {
+    const model = toPascalCase(m.name, cfg.initialisms);
+    const names = {
+        where: [`${model}WhereInput`, ...(cfg.relations ? [`${model}RelationFilter`, `${model}ListRelationFilter`] : [])],
+        whereUnique: [`${model}WhereUniqueInput`],
+        orderBy: [`${model}OrderByWithRelationInput`],
+        create: [`${model}UncheckedCreateInput`],
+        update: [`${model}UncheckedUpdateInput`],
+        select: [`${model}Select`],
+        include: [`${model}Include`],
+    };
+    return selected(cfg).flatMap((family) => names[family]);
+}
+/** Go type names sharedInputs declares. */
+export function sharedInputNames(cfg) {
+    return selected(cfg).flatMap((family) => (SHARED[family] ?? []).map(([name]) => name));
+}
+/** The input types of one model, for the families the config asks for. */
+export function modelInputs(m, cfg) {
+    const model = toPascalCase(m.name, cfg.initialisms);
+    const imports = [];
+    const goName = (field) => toPascalCase(field.name, cfg.initialisms);
+    const goType = (field) => {
+        const type = baseType(field, cfg);
+        imports.push(...type.imports);
+        return type.expr;
+    };
+    const columns = m.fields.filter((field) => field.kind !== 'object');
+    const relations = cfg.relations ? m.fields.filter((field) => field.kind === 'object') : [];
+    const target = (field) => toPascalCase(field.type, cfg.initialisms);
+    const families = {
+        where: () => {
+            const out = [
+                struct(`${model}WhereInput filters ${model} rows. Every condition that is set must hold.`, `${model}WhereInput`, [
+                    ...columns.map((f) => [goName(f), `*${whereFilter(f, goType(f))}`, optional(f.name)]),
+                    ...relations.map((f) => [goName(f), `*${target(f)}${f.isList ? 'ListRelationFilter' : 'RelationFilter'}`, optional(f.name)]),
+                    ['AND', `[]${model}WhereInput`, optional('AND')],
+                    ['OR', `[]${model}WhereInput`, optional('OR')],
+                    ['NOT', `[]${model}WhereInput`, optional('NOT')],
+                ]),
+            ];
+            if (cfg.relations) {
+                out.push(struct(`${model}RelationFilter filters through a to-one relation to ${model}.`, `${model}RelationFilter`, [
+                    ['Is', `*${model}WhereInput`, optional('is')],
+                    ['IsNot', `*${model}WhereInput`, optional('isNot')],
+                ]), struct(`${model}ListRelationFilter filters through a to-many relation to ${model}.`, `${model}ListRelationFilter`, [
+                    ['Some', `*${model}WhereInput`, optional('some')],
+                    ['Every', `*${model}WhereInput`, optional('every')],
+                    ['None', `*${model}WhereInput`, optional('none')],
+                ]));
+            }
+            return out;
+        },
+        whereUnique: () => {
+            const unique = uniqueColumns(m);
+            return [
+                struct(`${model}WhereUniqueInput identifies one ${model} row by its id or a unique column.`, `${model}WhereUniqueInput`, columns.filter((f) => unique.has(f.name) && !f.isList).map((f) => [goName(f), `*${goType(f)}`, optional(f.name)])),
+            ];
+        },
+        orderBy: () => [
+            struct(`${model}OrderByWithRelationInput orders ${model} rows. Use a slice of these to order by several columns.`, `${model}OrderByWithRelationInput`, [
+                ...columns.map((f) => [goName(f), 'SortOrder', optional(f.name)]),
+                ...relations.filter((f) => !f.isList).map((f) => [goName(f), `*${target(f)}OrderByWithRelationInput`, optional(f.name)]),
+            ]),
+        ],
+        create: () => [
+            struct(`${model}UncheckedCreateInput is the data for a new ${model} row. Columns with a default are optional.`, `${model}UncheckedCreateInput`, columns.map((f) => {
+                if (f.isList)
+                    return [goName(f), `[]${goType(f)}`, optional(f.name)];
+                const required = f.isRequired && !f.hasDefaultValue && !f.isUpdatedAt;
+                return required ? [goName(f), goType(f), f.name] : [goName(f), `*${goType(f)}`, optional(f.name)];
+            })),
+        ],
+        update: () => [
+            struct(`${model}UncheckedUpdateInput changes the columns that are set and leaves the rest alone.`, `${model}UncheckedUpdateInput`, columns.map((f) => [goName(f), `*${updateOperation(f, goType(f))}`, optional(f.name)])),
+        ],
+        select: () => [
+            struct(`${model}Select picks the fields of ${model} to return.`, `${model}Select`, [...columns, ...relations].map((f) => [goName(f), 'bool', optional(f.name)])),
+        ],
+        include: () => relations.length === 0
+            ? []
+            : [
+                struct(`${model}Include picks the relations of ${model} to load.`, `${model}Include`, relations.map((f) => [goName(f), 'bool', optional(f.name)])),
+            ],
+    };
+    return selected(cfg)
+        .flatMap((family) => families[family]())
+        .map((code) => ({ code, imports }));
+}

package/dist/layout.js

@@ -0,0 +1,101 @@
+import { modelInputNames, modelInputs, sharedInputNames, sharedInputs } from './inputs.js';
+import { toPascalCase, toSnakeCase } from './naming.js';
+import { renderEnum, renderModel } from './render.js';
+/** First line of every file this generator writes; pruning only deletes files that start with it. */
+export const HEADER = '// Code generated by prisma-go-generator. DO NOT EDIT.';
+// A trailing _test, _<GOOS> or _<GOARCH> in a file name is a build constraint to the go tool.
+const CONSTRAINT_SUFFIXES = new Set(('test aix android darwin dragonfly freebsd hurd illumos ios js linux nacl netbsd openbsd plan9 solaris wasip1 windows zos ' +
+    '386 amd64 amd64p32 arm arm64 arm64be armbe loong64 mips mips64 mips64le mips64p32 mips64p32le mipsle ppc ppc64 ppc64le ' +
+    'riscv riscv64 s390 s390x sparc sparc64 wasm').split(' '));
+/** Turns a model or schema-file name into a Go file name that the go tool always compiles. */
+export function goFileName(stem) {
+    let base = stem
+        .toLowerCase()
+        .replaceAll(/[^a-z0-9_]+/g, '_')
+        .replace(/^_+/, '');
+    if (base === '')
+        base = 'models';
+    if (CONSTRAINT_SUFFIXES.has(base.split('_').pop() ?? ''))
+        base += '_gen';
+    return `${base}.go`;
+}
+/**
+ * The file a model or enum is written to. `sources` maps Prisma declaration names to the name of
+ * the .prisma file they come from, and is only needed for the per-file layout.
+ */
+export function fileFor(kind, name, cfg, sources) {
+    if (cfg.layout === 'perModel')
+        return kind === 'enum' ? 'enums.go' : goFileName(toSnakeCase(name));
+    if (cfg.layout === 'perFile') {
+        const source = sources.get(name);
+        return source === undefined ? cfg.fileName : goFileName(source);
+    }
+    return cfg.fileName;
+}
+function assemble(pkg, parts) {
+    const imports = [...parts.imports].sort();
+    const blocks = [
+        `${HEADER}\npackage ${pkg}`,
+        ...(imports.length > 0 ? [`import (\n${imports.map((path) => `\t"${path}"`).join('\n')}\n)`] : []),
+        ...(parts.enums.length > 0 ? ['// Enums', ...parts.enums] : []),
+        ...(parts.models.length > 0 ? ['// Models', ...parts.models] : []),
+        ...(parts.inputs.length > 0 ? ['// Inputs', ...parts.inputs] : []),
+    ];
+    return `${blocks.join('\n\n')}\n`;
+}
+function checkTypeNames(datamodel, cfg) {
+    const taken = new Map();
+    const claim = (goName, owner) => {
+        const other = taken.get(goName);
+        if (other !== undefined)
+            throw new Error(`prisma-go-generator: ${other} and ${owner} both become the Go type ${goName}`);
+        taken.set(goName, owner);
+    };
+    for (const e of datamodel.enums)
+        claim(toPascalCase(e.name, cfg.initialisms), `enum ${e.name}`);
+    for (const m of datamodel.models)
+        claim(toPascalCase(m.name, cfg.initialisms), `model ${m.name}`);
+    if (cfg.inputs.length === 0)
+        return;
+    for (const name of sharedInputNames(cfg))
+        claim(name, 'the shared input types');
+    for (const m of datamodel.models) {
+        for (const name of modelInputNames(m, cfg))
+            claim(name, `the inputs of model ${m.name}`);
+    }
+}
+/** Renders the whole datamodel: Go file name -> unformatted Go source. */
+export function generateFiles(datamodel, cfg, sources = new Map()) {
+    checkTypeNames(datamodel, cfg);
+    const files = new Map();
+    const file = (name) => {
+        let parts = files.get(name);
+        if (!parts)
+            files.set(name, (parts = { imports: new Set(), enums: [], models: [], inputs: [] }));
+        return parts;
+    };
+    if (cfg.layout === 'single')
+        file(cfg.fileName);
+    for (const e of datamodel.enums)
+        file(fileFor('enum', e.name, cfg, sources)).enums.push(renderEnum(e, cfg));
+    const withInputs = cfg.inputs.length > 0 && datamodel.models.length > 0;
+    if (withInputs)
+        file(cfg.layout === 'single' ? cfg.fileName : 'inputs.go').inputs.push(...sharedInputs(cfg));
+    for (const m of datamodel.models) {
+        const parts = file(fileFor('model', m.name, cfg, sources));
+        const model = renderModel(m, cfg);
+        parts.models.push(model.code);
+        model.imports.forEach((path) => parts.imports.add(path));
+        if (!withInputs)
+            continue;
+        for (const input of modelInputs(m, cfg)) {
+            parts.inputs.push(input.code);
+            input.imports.forEach((path) => parts.imports.add(path));
+        }
+    }
+    return new Map([...files].map(([name, parts]) => [name, assemble(cfg.package, parts)]));
+}
+/** The single-file layout's one file. */
+export function render(datamodel, cfg) {
+    return generateFiles(datamodel, cfg).get(cfg.fileName) ?? '';
+}

package/dist/naming.js

@@ -0,0 +1,40 @@
+const NO_INITIALISMS = new Set();
+/**
+ * Converts a Prisma identifier to an exported Go identifier, the way prisma2go does: the first
+ * letter and any letter after `_`, `-` or a space is upper-cased and everything else is kept, so
+ * `user_name` and `userName` both become `UserName` and `USER_NAME` becomes `USERNAME`.
+ *
+ * Words that match one of the upper-case initialisms are upper-cased whole (`UserId` -> `UserID`).
+ */
+export function toPascalCase(s, initialisms = NO_INITIALISMS) {
+    let out = '';
+    let upperNext = true;
+    for (const ch of s) {
+        if (ch === '_' || ch === '-' || ch === ' ') {
+            upperNext = true;
+            continue;
+        }
+        out += upperNext ? ch.toUpperCase() : ch;
+        upperNext = false;
+    }
+    if (initialisms.size === 0)
+        return out;
+    return out.replace(/[A-Z][a-z0-9]*/g, (word) => (initialisms.has(word.toUpperCase()) ? word.toUpperCase() : word));
+}
+/** Names an enum constant: `Role` + `SUPER_USER` -> `RoleSuperUser`. */
+export function toEnumConstName(enumName, value, initialisms = NO_INITIALISMS) {
+    return enumName + toPascalCase(value.toLowerCase(), initialisms);
+}
+function words(s) {
+    return s.match(/[A-Z]+(?![a-z])|[A-Z]?[a-z]+|[0-9]+/g) ?? [];
+}
+export function toSnakeCase(s) {
+    return words(s)
+        .map((w) => w.toLowerCase())
+        .join('_');
+}
+export function toCamelCase(s) {
+    return words(s)
+        .map((w, i) => (i === 0 ? w.toLowerCase() : w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()))
+        .join('');
+}

package/dist/render.js

@@ -0,0 +1,94 @@
+import { toCamelCase, toEnumConstName, toPascalCase, toSnakeCase } from './naming.js';
+import { fieldType } from './types.js';
+export function renderEnum(e, cfg) {
+    const name = toPascalCase(e.name, cfg.initialisms);
+    const lines = [];
+    if (cfg.enumDirective)
+        lines.push(`//go:generate ${cfg.enumDirective.replaceAll('{name}', name)}`);
+    lines.push(`type ${name} ${cfg.enumType}`, '', 'const (');
+    e.values.forEach((value, i) => {
+        const constant = toEnumConstName(name, value.name, cfg.initialisms);
+        if (cfg.enumType === 'string')
+            lines.push(`\t${constant} ${name} = ${JSON.stringify(value.dbName ?? value.name)}`);
+        else
+            lines.push(i === 0 ? `\t${constant} ${name} = iota` : `\t${constant}`);
+    });
+    lines.push(')');
+    return lines.join('\n');
+}
+function tagName(tag, field, goName) {
+    switch (tag.naming) {
+        case 'field':
+            return field.name;
+        case 'column':
+            return field.dbName ?? field.name;
+        case 'snake':
+            return toSnakeCase(field.name);
+        case 'camel':
+            return toCamelCase(field.name);
+        case 'pascal':
+            return goName;
+    }
+}
+function structTag(tag, field, goName, cfg) {
+    if (field.kind === 'object') {
+        // A relation is not a column, and is only present once the caller has loaded it.
+        return tag.naming === 'column' ? `${tag.key}:"-"` : `${tag.key}:"${tagName(tag, field, goName)},omitempty"`;
+    }
+    const omit = cfg.omitempty.has(tag.key) && (!field.isRequired || field.hasDefaultValue);
+    return `${tag.key}:"${tagName(tag, field, goName)}${omit ? ',omitempty' : ''}"`;
+}
+// prisma2go lists @@unique groups from both uniqueIndexes and uniqueFields, so a group shows up
+// twice. Kept as is: the comment is part of the output existing users diff against.
+function indexComments(m) {
+    const lines = (m.uniqueIndexes ?? []).map((index) => `// Index: ${index.name ?? 'unique'} (${index.fields.join(', ')})`);
+    for (const fields of m.uniqueFields ?? []) {
+        if (fields.length > 0)
+            lines.push(`// Index: unique (${fields.join(', ')})`);
+    }
+    return lines;
+}
+export function renderModel(m, cfg) {
+    const name = toPascalCase(m.name, cfg.initialisms);
+    const table = m.dbName ?? m.name;
+    const imports = [];
+    const columns = [];
+    const relations = [];
+    const taken = new Map();
+    for (const field of m.fields) {
+        const isRelation = field.kind === 'object';
+        if (isRelation && !cfg.relations)
+            continue;
+        const goName = toPascalCase(field.name, cfg.initialisms);
+        const clash = taken.get(goName);
+        if (clash !== undefined) {
+            throw new Error(`prisma-go-generator: ${m.name}: fields "${clash}" and "${field.name}" both become ${goName} in Go`);
+        }
+        taken.set(goName, field.name);
+        const type = fieldType(field, cfg);
+        imports.push(...type.imports);
+        const tags = cfg.structTags.map((tag) => structTag(tag, field, goName, cfg));
+        const line = `\t${goName} ${type.expr}${tags.length > 0 ? ` \`${tags.join(' ')}\`` : ''}`;
+        if (isRelation) {
+            relations.push(line);
+            continue;
+        }
+        if (field.documentation)
+            columns.push(`\t// ${field.documentation.replaceAll('\n', '\n\t// ')}`);
+        columns.push(field.isId ? `${line} // primary key` : line);
+    }
+    const lines = [
+        m.documentation ? `// ${name} - ${m.documentation.replaceAll('\n', '\n// ')}` : `// ${name} represents the ${table} table.`,
+        ...indexComments(m),
+        `type ${name} struct {`,
+        ...columns,
+    ];
+    if (relations.length > 0)
+        lines.push('', '\t// Relations (not persisted, populate manually)', ...relations);
+    lines.push('}');
+    if (cfg.tableNameMethod) {
+        lines.push('', `// TableName returns the name of the table ${name} rows are stored in.`);
+        lines.push(`func (${name}) TableName() string { return ${JSON.stringify(table)} }`);
+    }
+    return { code: lines.join('\n'), imports };
+}

package/dist/types.js

@@ -0,0 +1,90 @@
+import { toPascalCase } from './naming.js';
+// Go types are written the way the `types` option takes them: a builtin as is, anything else as
+// `<import path>.<Name>`.
+const SCALARS = {
+    String: 'string',
+    Int: 'int32',
+    BigInt: 'int64',
+    Float: 'float64',
+    Boolean: 'bool',
+    DateTime: 'time.Time',
+    Json: 'encoding/json.RawMessage',
+    Bytes: '[]byte',
+    Decimal: 'string',
+};
+const NATIVE_TYPES = {
+    Uuid: 'github.com/google/uuid.UUID',
+    JsonB: 'encoding/json.RawMessage',
+    Json: 'encoding/json.RawMessage',
+    Text: 'string',
+    VarChar: 'string',
+    Char: 'string',
+    Citext: 'string',
+    SmallInt: 'int32',
+    Integer: 'int32',
+    Int2: 'int32',
+    Int4: 'int32',
+    BigInt: 'int64',
+    Int8: 'int64',
+    Real: 'float32',
+    Float4: 'float32',
+    DoublePrecision: 'float64',
+    Float8: 'float64',
+    Decimal: 'string',
+    Numeric: 'string',
+    Money: 'string',
+    Timestamp: 'time.Time',
+    Timestamptz: 'time.Time',
+    Date: 'time.Time',
+    Time: 'time.Time',
+    Timetz: 'time.Time',
+    ByteA: '[]byte',
+};
+const FALLBACK = 'encoding/json.RawMessage';
+/** The package name Go gives an import path: its last element, ignoring a major-version suffix. */
+function packageName(importPath) {
+    const parts = importPath.split('/');
+    let last = parts.pop() ?? importPath;
+    if (/^v\d+$/.test(last) && parts.length > 0)
+        last = parts.pop() ?? last;
+    return last.replace(/\.v\d+$/, '');
+}
+/**
+ * Parses a type spec: `string`, `[]byte` and `map[string]any` are used as written, while
+ * `github.com/google/uuid.UUID` becomes `uuid.UUID` plus an import. A qualified type may be
+ * prefixed with `*` or `[]`.
+ */
+export function parseGoType(spec) {
+    const match = /^((?:\[\]|\*)*)([\w./~-]+)\.([A-Za-z_]\w*)$/.exec(spec);
+    if (!match)
+        return { expr: spec, imports: [] };
+    const [, prefix = '', importPath = '', name = ''] = match;
+    return { expr: `${prefix}${packageName(importPath)}.${name}`, imports: [importPath] };
+}
+/** The Go type of a field before optional, list and relation wrapping. */
+export function baseType(field, cfg) {
+    if (field.kind === 'object' || field.kind === 'enum') {
+        return { expr: toPascalCase(field.type, cfg.initialisms), imports: [] };
+    }
+    const native = field.nativeType?.[0];
+    const spec = (native ? cfg.types[`db.${native}`] : undefined) ??
+        cfg.types[field.type] ??
+        (native ? NATIVE_TYPES[native] : undefined) ??
+        SCALARS[field.type] ??
+        FALLBACK;
+    return parseGoType(spec);
+}
+/** The Go type of a model struct field. */
+export function fieldType(field, cfg) {
+    const base = baseType(field, cfg);
+    if (field.isList)
+        return { expr: `[]${base.expr}`, imports: base.imports };
+    if (field.kind === 'object')
+        return { expr: `*${base.expr}`, imports: base.imports };
+    if (field.isRequired)
+        return base;
+    if (cfg.optionalType === 'pointer')
+        return { expr: `*${base.expr}`, imports: base.imports };
+    const wrapper = parseGoType(cfg.optionalType);
+    return { expr: `${wrapper.expr}[${base.expr}]`, imports: [...base.imports, ...wrapper.imports] };
+}

package/package.json

@@ -1,6 +1,54 @@
 {
   "name": "@tredy-ai/prisma-go-generator",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Prisma generator that emits Go structs and enums from your Prisma schema",
+  "license": "MIT",
+  "author": "Tredy AI, Inc.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tredy-ai/prisma-go-generator.git"
+  },
+  "keywords": [
+    "prisma",
+    "generator",
+    "prisma-generator",
+    "go",
+    "golang",
+    "codegen",
+    "structs"
+  ],
+  "type": "module",
+  "bin": {
+    "prisma-go-generator": "bin/prisma-go-generator.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "NOTICE"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "@tredy-ai:registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "node": ">=20.19"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepack": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "tsc -p tsconfig.build.json && vitest run"
+  },
+  "dependencies": {
+    "@prisma/generator-helper": "^7.0.0"
+  },
+  "peerDependencies": {
+    "prisma": ">=7.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "24.10.1",
+    "prisma": "7.10.1",
+    "typescript": "7.0.2",
+    "vitest": "5.1.0"
+  }
+}