@polyprism/php-shared 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Travis Fitzgerald
+
+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,46 @@
+# @polyprism/php-shared
+
+PHP rendering primitives shared by every `php-*` pattern in [PolyPrism](https://github.com/TravFitz/polyprism) — a Prisma 6 & 7 generator that emits typed code from your `schema.prisma` in whichever shape fits the layer you're writing.
+
+**Pure ESM, Prisma 7-native, zero third-party runtime dependencies on any published `@polyprism/*` package.**
+
+## You're probably looking for a pattern package
+
+You don't install `@polyprism/php-shared` directly — each `php-*` pattern package pulls it in transitively.
+
+| Install | What it emits |
+|---|---|
+| [`@polyprism/php-class`](https://www.npmjs.com/package/@polyprism/php-class) | `final class User { ... }` — PHP 8.1+, mutable, public typed properties via constructor property promotion |
+| [`@polyprism/php-readonly`](https://www.npmjs.com/package/@polyprism/php-readonly) | `final readonly class User { ... }` — PHP 8.2+, immutable value objects |
+
+## What lives here
+
+The PHP-specific layer between [`@polyprism/core`](https://www.npmjs.com/package/@polyprism/core)'s language-agnostic IR and the per-pattern emitters:
+
+- **`emitPhpModels(ctx, opts)`** — the top-level pipeline. Walks the IR, renders enums and models, surfaces any emit-time diagnostics, and writes everything to `<outputDir>/Enums/*.php` + `<outputDir>/Models/*.php`.
+- **`renderPhpModel(opts)`** — emits one model file as a PHP class. Two declaration styles (`"class"` and `"readonly"`) share the same field-by-field rendering loop; the keyword block at the top of the class is the only differentiator.
+- **`renderPhpEnum(opts)`** — emits a PHP 8.1+ backed enum (`enum Role: string { case ADMIN = 'ADMIN'; }`).
+- **`mapFieldPhpType`** — IR field → PHP type expression. Handles scalars, enums, relations, nullability, lists (with PHPDoc `@var array<int, T>` hints), and resolves `@json` references to generated value classes.
+- **`renderPhpJsonType`** — Parses a TS-shaped inline `@json` expression (a small supported subset) and emits a `final readonly class` for it. Nested objects collapse to PHPDoc `array{...}` shapes rather than spawning sub-classes.
+- **`UseCollector`** — deduped, sorted `use`-statement builder. Skips same-namespace references automatically.
+- **`renderPhpDoc`** — PHPDoc emission for `///` docs, `@deprecated` tags, native-type metadata, and list-element hints.
+
+## What's NOT in here (v0 scope)
+
+- `@coerce` / `@normalise` / `@noCoerce` annotations are recognised but ignored. They're domain-class concepts that need PHP 8.4 property hooks and a Composer-published runtime helper — that'll ship as a future `@polyprism/php-domain-class`.
+- TS unions / generics / identifier references inside an inline `@json` shape — fall back to `mixed` with a warning. Use `@type("\\App\\YourType")` to point at a hand-written PHP class for richer typing.
+- Bare and with-path `@json` forms (e.g. `@json(SomeType)`, `@json(SomeType from "./path")`) — these rely on TS module imports that don't translate to PHP autoloading. Warn + fall back to `mixed`.
+- Source-position line numbers on diagnostics — DMMF doesn't expose them, so issues carry `Model.field` context strings instead.
+
+## Why this is split out from `@polyprism/core`
+
+`@polyprism/core` is deliberately language-agnostic — IR, Prisma schema reader, annotation parser, naming resolver. `@polyprism/php-shared` is where PHP-specific concerns live. Both `php-class` and `php-readonly` share one PHP rendering layer, so they agree on type mapping, use-statement handling, and PHPDoc by construction — not by convention.
+
+## Links
+
+- [PolyPrism on GitHub](https://github.com/TravFitz/polyprism) — full feature list, annotation reference, side-by-side pattern examples
+- [Issue tracker](https://github.com/TravFitz/polyprism/issues)
+
+## License
+
+[MIT](https://github.com/TravFitz/polyprism/blob/main/LICENSE) © Travis Fitzgerald

package/dist/diagnostics.d.ts

@@ -0,0 +1,16 @@
+interface Diagnostic {
+    readonly severity: "error" | "warning";
+    /**
+     * Where the issue applies. Conventional shapes:
+     *   - `"User"`       — model
+     *   - `"User.email"` — model field
+     *   - `"Role"`       — enum
+     *   - `"Role.ADMIN"` — enum value
+     */
+    readonly context: string;
+    readonly message: string;
+}
+/** Default reporter: writes warnings and errors to stderr with a prefix tag. */
+declare function defaultReportDiagnostic(d: Diagnostic): void;
+
+export { type Diagnostic, defaultReportDiagnostic };

package/dist/diagnostics.js

@@ -0,0 +1,8 @@
+function defaultReportDiagnostic(d) {
+  const prefix = d.severity === "error" ? "[error]" : "[warn] ";
+  console.error(`PolyPrism ${prefix} ${d.context}: ${d.message}`);
+}
+export {
+  defaultReportDiagnostic
+};
+//# sourceMappingURL=diagnostics.js.map

package/dist/diagnostics.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/diagnostics.ts"],"sourcesContent":["// Diagnostic surface for PHP emit-time issues.\n//\n// Mirror of the ts-shared/src/diagnostics.ts shape. Kept local to php-shared\n// for v0 — both copies are tiny and the duplication keeps the PHP package\n// independent of the TS family at install time. A future cleanup will hoist\n// the type into @polyprism/core once a third family arrives (Go, Rust, ...)\n// and the duplication is no longer hypothetical.\n//\n// Two kinds of issues funnel through here:\n//   1. AnnotationSet.parseIssues recorded by the core annotation parser.\n//   2. PHP-emitter validations (e.g. unsupported @json forms, unhandled\n//      default-value shapes) that this package raises while rendering.\n\nexport interface Diagnostic {\n  readonly severity: \"error\" | \"warning\";\n  /**\n   * Where the issue applies. Conventional shapes:\n   *   - `\"User\"`       — model\n   *   - `\"User.email\"` — model field\n   *   - `\"Role\"`       — enum\n   *   - `\"Role.ADMIN\"` — enum value\n   */\n  readonly context: string;\n  readonly message: string;\n}\n\n/** Default reporter: writes warnings and errors to stderr with a prefix tag. */\nexport function defaultReportDiagnostic(d: Diagnostic): void {\n  const prefix = d.severity === \"error\" ? \"[error]\" : \"[warn] \";\n  // Prisma's JSON-RPC for generators is also on stderr, but its frames are\n  // pure JSON; ours start with \"PolyPrism \" and contain a colon, so the\n  // two stream types don't tangle when the Prisma CLI surfaces them.\n  console.error(`PolyPrism ${prefix} ${d.context}: ${d.message}`);\n}\n"],"mappings":"AA2BO,SAAS,wBAAwB,GAAqB;AAC3D,QAAM,SAAS,EAAE,aAAa,UAAU,YAAY;AAIpD,UAAQ,MAAM,aAAa,MAAM,IAAI,EAAE,OAAO,KAAK,EAAE,OAAO,EAAE;AAChE;","names":[]}

package/dist/emit-models.d.ts

@@ -0,0 +1,23 @@
+import { GeneratorContext } from '@polyprism/core';
+import { Diagnostic } from './diagnostics.js';
+import { PhpDeclarationStyle } from './render-model.js';
+
+interface EmitPhpModelsOptions {
+    readonly declarationStyle: PhpDeclarationStyle;
+    /**
+     * Root namespace for model classes. Default: `"Generated\\Models"`.
+     * Use a single backslash in source; this is a real PHP namespace string
+     * (no escape doubling required at runtime — the doubling shown here is
+     * just because backslash is the JS escape character).
+     */
+    readonly modelsNamespace?: string;
+    /** Root namespace for enum classes. Default: `"Generated\\Enums"`. */
+    readonly enumsNamespace?: string;
+    /** Root namespace for generated JSON value classes. Default: `"Generated\\JsonTypes"`. */
+    readonly jsonTypesNamespace?: string;
+    /** Optional diagnostic sink. Defaults to stderr. */
+    readonly onDiagnostic?: (diagnostic: Diagnostic) => void;
+}
+declare function emitPhpModels(ctx: GeneratorContext, opts: EmitPhpModelsOptions): Promise<void>;
+
+export { type EmitPhpModelsOptions, emitPhpModels };

package/dist/emit-models.js

@@ -0,0 +1,136 @@
+import { autoNameInlineJson, resolveTypeIdent } from "@polyprism/core";
+import { defaultReportDiagnostic } from "./diagnostics.js";
+import { renderPhpEnum } from "./render-enum.js";
+import { renderPhpJsonType } from "./render-json-type.js";
+import { renderPhpModel } from "./render-model.js";
+const DEFAULT_MODELS_NAMESPACE = "Generated\\Models";
+const DEFAULT_ENUMS_NAMESPACE = "Generated\\Enums";
+const DEFAULT_JSON_TYPES_NAMESPACE = "Generated\\JsonTypes";
+async function emitPhpModels(ctx, opts) {
+  const report = opts.onDiagnostic ?? defaultReportDiagnostic;
+  const modelsNamespace = opts.modelsNamespace ?? DEFAULT_MODELS_NAMESPACE;
+  const enumsNamespace = opts.enumsNamespace ?? DEFAULT_ENUMS_NAMESPACE;
+  const jsonTypesNamespace = opts.jsonTypesNamespace ?? DEFAULT_JSON_TYPES_NAMESPACE;
+  let errorCount = 0;
+  const emit = (d) => {
+    if (d.severity === "error") errorCount += 1;
+    report(d);
+  };
+  for (const diag of collectParseDiagnostics(ctx.ir)) emit(diag);
+  for (const enumDef of ctx.ir.enums) {
+    if (enumDef.annotations.hide) continue;
+    const filename = resolveTypeIdent({
+      schemaName: enumDef.name,
+      override: enumDef.annotations.name,
+      convention: ctx.config.naming.typeNaming
+    });
+    const source = renderPhpEnum({
+      enumDef,
+      naming: ctx.config.naming,
+      namespace: enumsNamespace
+    });
+    await ctx.writer.write(`Enums/${filename}.php`, source);
+  }
+  const jsonTypesEmitted = /* @__PURE__ */ new Map();
+  const jsonTypeOrigin = /* @__PURE__ */ new Map();
+  for (const model of ctx.ir.models) {
+    if (model.annotations.hide) continue;
+    for (const field of model.fields) {
+      if (field.annotations.hide) continue;
+      const json = field.annotations.json;
+      if (!json) continue;
+      let typeName = null;
+      let typeExpression = null;
+      if (json.kind === "inline-anonymous") {
+        typeName = autoNameInlineJson(model.name, field.name);
+        typeExpression = json.typeExpression;
+      } else if (json.kind === "inline-named") {
+        typeName = json.typeName;
+        typeExpression = json.typeExpression;
+      }
+      if (!typeName || typeExpression === null) continue;
+      const origin = `${model.name}.${field.name}`;
+      const existing = jsonTypesEmitted.get(typeName);
+      if (existing !== void 0 && existing !== typeExpression) {
+        emit({
+          severity: "warning",
+          context: origin,
+          message: `@json auto-naming collision: ${origin} produced JsonType class "${typeName}" but a different shape from ${jsonTypeOrigin.get(typeName)} already registered the same name. The later shape wins; the earlier field's runtime class will not match its schema-declared shape. Disambiguate with \`@json(<UniqueName> = { ... })\`.`
+        });
+      }
+      jsonTypesEmitted.set(typeName, typeExpression);
+      if (!jsonTypeOrigin.has(typeName)) jsonTypeOrigin.set(typeName, origin);
+    }
+  }
+  const successfullyEmitted = /* @__PURE__ */ new Set();
+  for (const [typeName, expression] of jsonTypesEmitted) {
+    const { source, issues } = renderPhpJsonType({
+      typeName,
+      typeExpression: expression,
+      namespace: jsonTypesNamespace,
+      // Best-effort context: there's no single source field for a named
+      // shape that's referenced from multiple places, so the JSON type
+      // class itself is the locus.
+      diagnosticContext: `JsonTypes.${typeName}`,
+      // JsonType readonly syntax follows the parent's declaration style —
+      // per-property `readonly` for `php-class` (PHP 8.1 floor) so we don't
+      // silently emit 8.2-only `final readonly class` syntax from an 8.1-
+      // documented package. Same semantics either way.
+      declarationStyle: opts.declarationStyle
+    });
+    for (const issue of issues) emit(issue);
+    if (source.length === 0) {
+      continue;
+    }
+    await ctx.writer.write(`JsonTypes/${typeName}.php`, source);
+    successfullyEmitted.add(typeName);
+  }
+  for (const model of ctx.ir.models) {
+    if (model.annotations.hide) continue;
+    const filename = resolveTypeIdent({
+      schemaName: model.name,
+      override: model.annotations.name,
+      convention: ctx.config.naming.typeNaming
+    });
+    const { source, issues } = renderPhpModel({
+      model,
+      ir: ctx.ir,
+      config: ctx.config,
+      declarationStyle: opts.declarationStyle,
+      modelsNamespace,
+      enumsNamespace,
+      jsonTypesNamespace,
+      jsonTypeClassNames: successfullyEmitted
+    });
+    for (const issue of issues) emit(issue);
+    await ctx.writer.write(`Models/${filename}.php`, source);
+  }
+  if (errorCount > 0) {
+    throw new Error(
+      `PolyPrism: PHP emit failed with ${errorCount} error-severity diagnostic${errorCount === 1 ? "" : "s"}. See the messages above for details.`
+    );
+  }
+}
+function* collectParseDiagnostics(ir) {
+  for (const model of ir.models) {
+    yield* parseIssuesFor(model.annotations, model.name);
+    for (const field of model.fields) {
+      yield* parseIssuesFor(field.annotations, `${model.name}.${field.name}`);
+    }
+  }
+  for (const enumDef of ir.enums) {
+    yield* parseIssuesFor(enumDef.annotations, enumDef.name);
+    for (const value of enumDef.values) {
+      yield* parseIssuesFor(value.annotations, `${enumDef.name}.${value.name}`);
+    }
+  }
+}
+function* parseIssuesFor(annotations, context) {
+  for (const issue of annotations.parseIssues) {
+    yield { severity: issue.severity, context, message: issue.message };
+  }
+}
+export {
+  emitPhpModels
+};
+//# sourceMappingURL=emit-models.js.map

package/dist/emit-models.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/emit-models.ts"],"sourcesContent":["// Top-level emit pipeline for the PHP family (php-class, php-readonly).\n//\n// Layout produced on disk (relative to the generator's outputDir):\n//\n//   <outputDir>/\n//     Models/\n//       User.php\n//       Order.php\n//     Enums/\n//       Role.php\n//\n// Each file declares its PSR-4 namespace as the first non-php-tag line,\n// so users can wire the generated directory into composer.json autoload\n// with a single mapping:\n//\n//   \"autoload\": {\n//     \"psr-4\": {\n//       \"Generated\\\\\": \"src/Generated/\"\n//     }\n//   }\n//\n// Annotations honoured (v0):\n//   - @hide          — field is omitted from the class body\n//   - @deprecated    — emits a PHPDoc @deprecated tag\n//   - @name          — overrides the class / field identifier verbatim\n//   - @type          — overrides the field's PHP type expression verbatim\n//   - @json(...)     — inline forms (anonymous + named) generate readonly\n//     value classes under JsonTypes/; the Json field's type resolves to the\n//     generated class name. Bare and with-path forms emit a warning and\n//     fall back to `mixed` (PHP has no equivalent of TS module imports).\n//\n// Annotations recognised but ignored (intentional v0 scope):\n//   - @coerce / @normalise / @noCoerce — domain-class concepts that need\n//     PHP 8.4 property hooks + a runtime helper. Will land as php-domain-class.\n//\n// Errors propagate the same way the ts-shared pipeline does: per-issue\n// onDiagnostic callback (defaults to stderr), accumulate error-severity\n// count, throw at the end if non-zero.\n\nimport type { AnnotationSet, EnumDef, GeneratorContext, ModelDef } from \"@polyprism/core\";\nimport { autoNameInlineJson, resolveTypeIdent } from \"@polyprism/core\";\n\nimport { type Diagnostic, defaultReportDiagnostic } from \"./diagnostics.js\";\nimport { renderPhpEnum } from \"./render-enum.js\";\nimport { renderPhpJsonType } from \"./render-json-type.js\";\nimport { type PhpDeclarationStyle, renderPhpModel } from \"./render-model.js\";\n\nexport interface EmitPhpModelsOptions {\n  readonly declarationStyle: PhpDeclarationStyle;\n  /**\n   * Root namespace for model classes. Default: `\"Generated\\\\Models\"`.\n   * Use a single backslash in source; this is a real PHP namespace string\n   * (no escape doubling required at runtime — the doubling shown here is\n   * just because backslash is the JS escape character).\n   */\n  readonly modelsNamespace?: string;\n  /** Root namespace for enum classes. Default: `\"Generated\\\\Enums\"`. */\n  readonly enumsNamespace?: string;\n  /** Root namespace for generated JSON value classes. Default: `\"Generated\\\\JsonTypes\"`. */\n  readonly jsonTypesNamespace?: string;\n  /** Optional diagnostic sink. Defaults to stderr. */\n  readonly onDiagnostic?: (diagnostic: Diagnostic) => void;\n}\n\nconst DEFAULT_MODELS_NAMESPACE = \"Generated\\\\Models\";\nconst DEFAULT_ENUMS_NAMESPACE = \"Generated\\\\Enums\";\nconst DEFAULT_JSON_TYPES_NAMESPACE = \"Generated\\\\JsonTypes\";\n\nexport async function emitPhpModels(\n  ctx: GeneratorContext,\n  opts: EmitPhpModelsOptions,\n): Promise<void> {\n  const report = opts.onDiagnostic ?? defaultReportDiagnostic;\n  const modelsNamespace = opts.modelsNamespace ?? DEFAULT_MODELS_NAMESPACE;\n  const enumsNamespace = opts.enumsNamespace ?? DEFAULT_ENUMS_NAMESPACE;\n  const jsonTypesNamespace = opts.jsonTypesNamespace ?? DEFAULT_JSON_TYPES_NAMESPACE;\n  let errorCount = 0;\n\n  const emit = (d: Diagnostic): void => {\n    if (d.severity === \"error\") errorCount += 1;\n    report(d);\n  };\n\n  // (1) Parser issues — recorded across models, fields, enums, enum values.\n  for (const diag of collectParseDiagnostics(ctx.ir)) emit(diag);\n\n  // (2) Enums — one file per visible enum, under <outputDir>/Enums/<Name>.php\n  for (const enumDef of ctx.ir.enums) {\n    if (enumDef.annotations.hide) continue;\n    const filename = resolveTypeIdent({\n      schemaName: enumDef.name,\n      override: enumDef.annotations.name,\n      convention: ctx.config.naming.typeNaming,\n    });\n    const source = renderPhpEnum({\n      enumDef,\n      naming: ctx.config.naming,\n      namespace: enumsNamespace,\n    });\n    await ctx.writer.write(`Enums/${filename}.php`, source);\n  }\n\n  // (3) JSON value classes — one file per inline @json shape (forms 3 + 4),\n  //     under <outputDir>/JsonTypes/<Name>.php. Bare and with-path forms\n  //     reference user-supplied types and are warned about in the type\n  //     mapper rather than generating files here.\n  const jsonTypesEmitted = new Map<string, string>();\n  // Track which field first registered each JsonType name so collision\n  // warnings can point at both sides.\n  const jsonTypeOrigin = new Map<string, string>();\n  for (const model of ctx.ir.models) {\n    if (model.annotations.hide) continue;\n    for (const field of model.fields) {\n      if (field.annotations.hide) continue;\n      const json = field.annotations.json;\n      if (!json) continue;\n      let typeName: string | null = null;\n      let typeExpression: string | null = null;\n      if (json.kind === \"inline-anonymous\") {\n        typeName = autoNameInlineJson(model.name, field.name);\n        typeExpression = json.typeExpression;\n      } else if (json.kind === \"inline-named\") {\n        typeName = json.typeName;\n        typeExpression = json.typeExpression;\n      }\n      if (!typeName || typeExpression === null) continue;\n\n      const origin = `${model.name}.${field.name}`;\n      const existing = jsonTypesEmitted.get(typeName);\n      if (existing !== undefined && existing !== typeExpression) {\n        // Two different inline @json shapes resolved to the same class\n        // name. Common ways this happens: two inline-anonymous fields\n        // whose Model+Field PascalCase to the same identifier, or two\n        // inline-named declarations sharing a name with different shapes.\n        // Last-write-wins matches the core TS pipeline behaviour, but\n        // PHP's nominal typing makes a silent shape mismatch nastier\n        // than TS's structural one (the class is what it is at runtime,\n        // not what the consumer expected). Warn loudly so the user can\n        // disambiguate with @json(<UniqueName> = { ... }).\n        emit({\n          severity: \"warning\",\n          context: origin,\n          message:\n            `@json auto-naming collision: ${origin} produced JsonType class ` +\n            `\"${typeName}\" but a different shape from ${jsonTypeOrigin.get(typeName)} ` +\n            \"already registered the same name. The later shape wins; the earlier \" +\n            \"field's runtime class will not match its schema-declared shape. \" +\n            \"Disambiguate with `@json(<UniqueName> = { ... })`.\",\n        });\n      }\n      jsonTypesEmitted.set(typeName, typeExpression);\n      if (!jsonTypeOrigin.has(typeName)) jsonTypeOrigin.set(typeName, origin);\n    }\n  }\n  // Drive the type-mapper off the SUCCESSFUL set (built below), not the\n  // intent set above. Otherwise an unparseable expression would still\n  // register a `use` for a class that was never written.\n  const successfullyEmitted = new Set<string>();\n  for (const [typeName, expression] of jsonTypesEmitted) {\n    const { source, issues } = renderPhpJsonType({\n      typeName,\n      typeExpression: expression,\n      namespace: jsonTypesNamespace,\n      // Best-effort context: there's no single source field for a named\n      // shape that's referenced from multiple places, so the JSON type\n      // class itself is the locus.\n      diagnosticContext: `JsonTypes.${typeName}`,\n      // JsonType readonly syntax follows the parent's declaration style —\n      // per-property `readonly` for `php-class` (PHP 8.1 floor) so we don't\n      // silently emit 8.2-only `final readonly class` syntax from an 8.1-\n      // documented package. Same semantics either way.\n      declarationStyle: opts.declarationStyle,\n    });\n    for (const issue of issues) emit(issue);\n    if (source.length === 0) {\n      // Renderer rejected the expression as unparseable. The warning has\n      // already been emitted; the field will fall back to `mixed` when\n      // the type-mapper checks `successfullyEmitted`.\n      continue;\n    }\n    await ctx.writer.write(`JsonTypes/${typeName}.php`, source);\n    successfullyEmitted.add(typeName);\n  }\n\n  // (4) Models — one file per visible model, under <outputDir>/Models/<Name>.php\n  for (const model of ctx.ir.models) {\n    if (model.annotations.hide) continue;\n    const filename = resolveTypeIdent({\n      schemaName: model.name,\n      override: model.annotations.name,\n      convention: ctx.config.naming.typeNaming,\n    });\n    const { source, issues } = renderPhpModel({\n      model,\n      ir: ctx.ir,\n      config: ctx.config,\n      declarationStyle: opts.declarationStyle,\n      modelsNamespace,\n      enumsNamespace,\n      jsonTypesNamespace,\n      jsonTypeClassNames: successfullyEmitted,\n    });\n    for (const issue of issues) emit(issue);\n    await ctx.writer.write(`Models/${filename}.php`, source);\n  }\n\n  if (errorCount > 0) {\n    throw new Error(\n      `PolyPrism: PHP emit failed with ${errorCount} error-severity ` +\n        `diagnostic${errorCount === 1 ? \"\" : \"s\"}. See the messages above for details.`,\n    );\n  }\n}\n\nfunction* collectParseDiagnostics(ir: {\n  readonly models: readonly ModelDef[];\n  readonly enums: readonly EnumDef[];\n}): Generator<Diagnostic> {\n  for (const model of ir.models) {\n    yield* parseIssuesFor(model.annotations, model.name);\n    for (const field of model.fields) {\n      yield* parseIssuesFor(field.annotations, `${model.name}.${field.name}`);\n    }\n  }\n  for (const enumDef of ir.enums) {\n    yield* parseIssuesFor(enumDef.annotations, enumDef.name);\n    for (const value of enumDef.values) {\n      yield* parseIssuesFor(value.annotations, `${enumDef.name}.${value.name}`);\n    }\n  }\n}\n\nfunction* parseIssuesFor(annotations: AnnotationSet, context: string): Generator<Diagnostic> {\n  for (const issue of annotations.parseIssues) {\n    yield { severity: issue.severity, context, message: issue.message };\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { Diagnostic, defaultReportDiagnostic } from './diagnostics.js';
+export { EmitPhpModelsOptions, emitPhpModels } from './emit-models.js';
+export { RenderPhpDocOptions, buildNativeTypeTag, renderPhpDoc } from './phpdoc.js';
+export { RenderEnumOptions, renderPhpEnum } from './render-enum.js';
+export { RenderJsonTypeOptions, RenderJsonTypeResult, renderPhpJsonType } from './render-json-type.js';
+export { PhpDeclarationStyle, RenderPhpModelOptions, RenderPhpModelResult, renderPhpModel } from './render-model.js';
+export { PhpTypeMapperOptions, PhpTypeMapping, mapFieldPhpType } from './type-mapper.js';
+export { UseCollector } from './use-collector.js';
+import '@polyprism/core';

package/dist/index.js

@@ -0,0 +1,9 @@
+export * from "./diagnostics.js";
+export * from "./emit-models.js";
+export * from "./phpdoc.js";
+export * from "./render-enum.js";
+export * from "./render-json-type.js";
+export * from "./render-model.js";
+export * from "./type-mapper.js";
+export * from "./use-collector.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from \"./diagnostics.js\";\nexport * from \"./emit-models.js\";\nexport * from \"./phpdoc.js\";\nexport * from \"./render-enum.js\";\nexport * from \"./render-json-type.js\";\nexport * from \"./render-model.js\";\nexport * from \"./type-mapper.js\";\nexport * from \"./use-collector.js\";\n"],"mappings":"AAAA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;","names":[]}

package/dist/phpdoc.d.ts

@@ -0,0 +1,16 @@
+import { NativeType, AnnotationSet } from '@polyprism/core';
+
+interface RenderPhpDocOptions {
+    /** Number of leading spaces before each `*` line. 0 for top-level, 4 for class members. */
+    readonly indent: number;
+    /** Optional extra tag lines, each as `@tag content` without the leading `* `. */
+    readonly extraTags?: readonly string[];
+}
+declare function renderPhpDoc(annotations: AnnotationSet, opts: RenderPhpDocOptions): string;
+/**
+ * Build the @db.X native-type tag line if the field has Prisma native-type
+ * metadata. Returns null if none — caller spreads into extraTags.
+ */
+declare function buildNativeTypeTag(nativeType: NativeType | null): string | null;
+
+export { type RenderPhpDocOptions, buildNativeTypeTag, renderPhpDoc };

package/dist/phpdoc.js

@@ -0,0 +1,32 @@
+function renderPhpDoc(annotations, opts) {
+  const lines = [];
+  if (annotations.documentation) {
+    for (const docLine of annotations.documentation.split("\n")) {
+      lines.push(docLine);
+    }
+  }
+  if (annotations.deprecated) {
+    const reason = annotations.deprecated.reason;
+    lines.push(reason ? `@deprecated ${reason}` : "@deprecated");
+  }
+  for (const tag of opts.extraTags ?? []) {
+    lines.push(tag);
+  }
+  if (lines.length === 0) return "";
+  const pad = " ".repeat(opts.indent);
+  const body = lines.map((line) => `${pad} * ${line}`).join("\n");
+  return `${pad}/**
+${body}
+${pad} */
+`;
+}
+function buildNativeTypeTag(nativeType) {
+  if (!nativeType) return null;
+  const args = nativeType.args.join(", ");
+  return args ? `@db.${nativeType.name}(${args})` : `@db.${nativeType.name}`;
+}
+export {
+  buildNativeTypeTag,
+  renderPhpDoc
+};
+//# sourceMappingURL=phpdoc.js.map

package/dist/phpdoc.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/phpdoc.ts"],"sourcesContent":["// PHPDoc block emission for models, fields, and enums.\n//\n// PHPDoc is the de-facto comment format read by IDEs (PhpStorm, VS Code via\n// Intelephense), static analysers (PHPStan, Psalm), and `phpdoc` itself.\n// We emit it for:\n//   - `///` documentation lines from the Prisma schema (preserved verbatim\n//     as the doc body)\n//   - `@deprecated` tags (with optional reason from `@deprecated(\"reason\")`)\n//   - `@db.X(precision, scale)` native-type metadata (kept as a tag because\n//     PHP has no native Decimal precision generics, same reasoning as the\n//     TS family — precision is schema-level info worth preserving)\n//   - PHPDoc `@var` hints for list types — PHP's native `array` doesn't\n//     carry an element type, so we annotate with `@var array<int, Type>`\n//     so static analysers see the intended shape.\n//\n// The output is always either:\n//   - empty string (no doc, no tags, no extras → no block)\n//   - a multi-line `/** ... */` block ending with a newline\n\nimport type { AnnotationSet, NativeType } from \"@polyprism/core\";\n\nexport interface RenderPhpDocOptions {\n  /** Number of leading spaces before each `*` line. 0 for top-level, 4 for class members. */\n  readonly indent: number;\n  /** Optional extra tag lines, each as `@tag content` without the leading `* `. */\n  readonly extraTags?: readonly string[];\n}\n\nexport function renderPhpDoc(annotations: AnnotationSet, opts: RenderPhpDocOptions): string {\n  const lines: string[] = [];\n\n  if (annotations.documentation) {\n    for (const docLine of annotations.documentation.split(\"\\n\")) {\n      lines.push(docLine);\n    }\n  }\n\n  if (annotations.deprecated) {\n    const reason = annotations.deprecated.reason;\n    // PHPDoc `@deprecated` follows the same shape as JSDoc/Javadoc.\n    lines.push(reason ? `@deprecated ${reason}` : \"@deprecated\");\n  }\n\n  for (const tag of opts.extraTags ?? []) {\n    lines.push(tag);\n  }\n\n  if (lines.length === 0) return \"\";\n\n  const pad = \" \".repeat(opts.indent);\n  const body = lines.map((line) => `${pad} * ${line}`).join(\"\\n\");\n  return `${pad}/**\\n${body}\\n${pad} */\\n`;\n}\n\n/**\n * Build the @db.X native-type tag line if the field has Prisma native-type\n * metadata. Returns null if none — caller spreads into extraTags.\n */\nexport function buildNativeTypeTag(nativeType: NativeType | null): string | null {\n  if (!nativeType) return null;\n  const args = nativeType.args.join(\", \");\n  return args ? `@db.${nativeType.name}(${args})` : `@db.${nativeType.name}`;\n}\n"],"mappings":"AA4BO,SAAS,aAAa,aAA4B,MAAmC;AAC1F,QAAM,QAAkB,CAAC;AAEzB,MAAI,YAAY,eAAe;AAC7B,eAAW,WAAW,YAAY,cAAc,MAAM,IAAI,GAAG;AAC3D,YAAM,KAAK,OAAO;AAAA,IACpB;AAAA,EACF;AAEA,MAAI,YAAY,YAAY;AAC1B,UAAM,SAAS,YAAY,WAAW;AAEtC,UAAM,KAAK,SAAS,eAAe,MAAM,KAAK,aAAa;AAAA,EAC7D;AAEA,aAAW,OAAO,KAAK,aAAa,CAAC,GAAG;AACtC,UAAM,KAAK,GAAG;AAAA,EAChB;AAEA,MAAI,MAAM,WAAW,EAAG,QAAO;AAE/B,QAAM,MAAM,IAAI,OAAO,KAAK,MAAM;AAClC,QAAM,OAAO,MAAM,IAAI,CAAC,SAAS,GAAG,GAAG,MAAM,IAAI,EAAE,EAAE,KAAK,IAAI;AAC9D,SAAO,GAAG,GAAG;AAAA,EAAQ,IAAI;AAAA,EAAK,GAAG;AAAA;AACnC;AAMO,SAAS,mBAAmB,YAA8C;AAC/E,MAAI,CAAC,WAAY,QAAO;AACxB,QAAM,OAAO,WAAW,KAAK,KAAK,IAAI;AACtC,SAAO,OAAO,OAAO,WAAW,IAAI,IAAI,IAAI,MAAM,OAAO,WAAW,IAAI;AAC1E;","names":[]}

package/dist/render-enum.d.ts

@@ -0,0 +1,10 @@
+import { EnumDef, NamingConfig } from '@polyprism/core';
+
+interface RenderEnumOptions {
+    readonly enumDef: EnumDef;
+    readonly naming: NamingConfig;
+    readonly namespace: string;
+}
+declare function renderPhpEnum(opts: RenderEnumOptions): string;
+
+export { type RenderEnumOptions, renderPhpEnum };

package/dist/render-enum.js

@@ -0,0 +1,36 @@
+import { resolveTypeIdent } from "@polyprism/core";
+import { renderPhpDoc } from "./phpdoc.js";
+function renderPhpEnum(opts) {
+  const { enumDef, naming, namespace } = opts;
+  const ident = resolveTypeIdent({
+    schemaName: enumDef.name,
+    override: enumDef.annotations.name,
+    convention: naming.typeNaming
+  });
+  const visibleValues = enumDef.values.filter((v) => !v.annotations.hide);
+  const caseLines = visibleValues.map(renderEnumCase).join("\n");
+  const headerDoc = renderPhpDoc(enumDef.annotations, { indent: 0 });
+  return [
+    "<?php",
+    "",
+    "declare(strict_types=1);",
+    "",
+    `namespace ${namespace};`,
+    "",
+    `${headerDoc}enum ${ident}: string
+{
+${caseLines}
+}`,
+    ""
+  ].join("\n");
+}
+function renderEnumCase(value) {
+  const dbValue = value.dbName ?? value.name;
+  const escapedValue = dbValue.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  const docBlock = renderPhpDoc(value.annotations, { indent: 4 });
+  return `${docBlock}    case ${value.name} = '${escapedValue}';`;
+}
+export {
+  renderPhpEnum
+};
+//# sourceMappingURL=render-enum.js.map

package/dist/render-enum.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/render-enum.ts"],"sourcesContent":["// Renders one Prisma enum as a PHP 8.1+ backed enum (string-typed).\n//\n// Output shape:\n//\n//   <?php\n//\n//   declare(strict_types=1);\n//\n//   namespace Generated\\Enums;\n//\n//   /**\n//    * Doc lines from `///` comments above the schema enum, if any.\n//    * @deprecated If the enum has @deprecated\n//    */\n//   enum Role: string\n//   {\n//       case ADMIN = 'ADMIN';\n//       case MEMBER = 'MEMBER';\n//   }\n//\n// Backed enums (`enum X: string`) were chosen over pure enums because:\n//   - Prisma stores enums in the database as strings; round-tripping through\n//     `Role::from($dbValue)` and `$enum->value` is the natural mapping.\n//   - PHPStan / Psalm / PhpStorm all narrow `enum X: string` cases on\n//     equality with string literals, so callers can do\n//     `if ($role->value === 'ADMIN')` without losing autocompletion.\n\nimport type { EnumDef, EnumValueDef, NamingConfig } from \"@polyprism/core\";\nimport { resolveTypeIdent } from \"@polyprism/core\";\n\nimport { renderPhpDoc } from \"./phpdoc.js\";\n\nexport interface RenderEnumOptions {\n  readonly enumDef: EnumDef;\n  readonly naming: NamingConfig;\n  readonly namespace: string;\n}\n\nexport function renderPhpEnum(opts: RenderEnumOptions): string {\n  const { enumDef, naming, namespace } = opts;\n  const ident = resolveTypeIdent({\n    schemaName: enumDef.name,\n    override: enumDef.annotations.name,\n    convention: naming.typeNaming,\n  });\n\n  const visibleValues = enumDef.values.filter((v) => !v.annotations.hide);\n  const caseLines = visibleValues.map(renderEnumCase).join(\"\\n\");\n  const headerDoc = renderPhpDoc(enumDef.annotations, { indent: 0 });\n\n  return [\n    \"<?php\",\n    \"\",\n    \"declare(strict_types=1);\",\n    \"\",\n    `namespace ${namespace};`,\n    \"\",\n    `${headerDoc}enum ${ident}: string\\n{\\n${caseLines}\\n}`,\n    \"\",\n  ].join(\"\\n\");\n}\n\nfunction renderEnumCase(value: EnumValueDef): string {\n  // Prisma allows `@map(\"DB_VALUE\")` on enum values via `dbName`. Honour\n  // that as the case's backing-string value so consumers can match against\n  // what the database actually stores.\n  const dbValue = value.dbName ?? value.name;\n  // Single-quoted PHP strings don't process escapes for anything except\n  // `\\\\` and `\\'`. JSON.stringify gives us double-quoted; flip the quotes\n  // and escape any apostrophes in the (very rare) case the value contains\n  // one. Realistic Prisma enum values are uppercase ASCII identifiers, so\n  // the escape branch is defensive.\n  const escapedValue = dbValue.replace(/\\\\/g, \"\\\\\\\\\").replace(/'/g, \"\\\\'\");\n  const docBlock = renderPhpDoc(value.annotations, { indent: 4 });\n  return `${docBlock}    case ${value.name} = '${escapedValue}';`;\n}\n"],"mappings":"AA4BA,SAAS,wBAAwB;AAEjC,SAAS,oBAAoB;AAQtB,SAAS,cAAc,MAAiC;AAC7D,QAAM,EAAE,SAAS,QAAQ,UAAU,IAAI;AACvC,QAAM,QAAQ,iBAAiB;AAAA,IAC7B,YAAY,QAAQ;AAAA,IACpB,UAAU,QAAQ,YAAY;AAAA,IAC9B,YAAY,OAAO;AAAA,EACrB,CAAC;AAED,QAAM,gBAAgB,QAAQ,OAAO,OAAO,CAAC,MAAM,CAAC,EAAE,YAAY,IAAI;AACtE,QAAM,YAAY,cAAc,IAAI,cAAc,EAAE,KAAK,IAAI;AAC7D,QAAM,YAAY,aAAa,QAAQ,aAAa,EAAE,QAAQ,EAAE,CAAC;AAEjE,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,aAAa,SAAS;AAAA,IACtB;AAAA,IACA,GAAG,SAAS,QAAQ,KAAK;AAAA;AAAA,EAAgB,SAAS;AAAA;AAAA,IAClD;AAAA,EACF,EAAE,KAAK,IAAI;AACb;AAEA,SAAS,eAAe,OAA6B;AAInD,QAAM,UAAU,MAAM,UAAU,MAAM;AAMtC,QAAM,eAAe,QAAQ,QAAQ,OAAO,MAAM,EAAE,QAAQ,MAAM,KAAK;AACvE,QAAM,WAAW,aAAa,MAAM,aAAa,EAAE,QAAQ,EAAE,CAAC;AAC9D,SAAO,GAAG,QAAQ,YAAY,MAAM,IAAI,OAAO,YAAY;AAC7D;","names":[]}

package/dist/render-json-type.d.ts

@@ -0,0 +1,32 @@
+import { Diagnostic } from './diagnostics.js';
+
+interface RenderJsonTypeOptions {
+    /** Top-level class name, e.g. "BillingAddress". */
+    readonly typeName: string;
+    /** Raw TS expression from the @json annotation, e.g. `{ street: string, city: string }`. */
+    readonly typeExpression: string;
+    /** PHP namespace the generated class lives in, e.g. `"Generated\\JsonTypes"`. */
+    readonly namespace: string;
+    /**
+     * Context string for diagnostics — typically `"Model.field"` so users can
+     * find the schema source of an unsupported-shape warning.
+     */
+    readonly diagnosticContext: string;
+    /**
+     * Determines the readonly syntax used:
+     *   - `"class"`: emit `final class Foo` with per-property `public readonly`
+     *     (works on PHP 8.1). Matches the floor of the `php-class` generator.
+     *   - `"readonly"`: emit `final readonly class Foo` (class-level modifier,
+     *     PHP 8.2+). Matches the floor of the `php-readonly` generator.
+     * Semantically both produce a value object whose properties can't be
+     * reassigned after construction; only the syntax differs.
+     */
+    readonly declarationStyle: "class" | "readonly";
+}
+interface RenderJsonTypeResult {
+    readonly source: string;
+    readonly issues: readonly Diagnostic[];
+}
+declare function renderPhpJsonType(opts: RenderJsonTypeOptions): RenderJsonTypeResult;
+
+export { type RenderJsonTypeOptions, type RenderJsonTypeResult, renderPhpJsonType };