typespec-http-zod 0.32.0 → 0.33.0

package/dist/src/api.d.ts

@@ -575,6 +575,43 @@ export interface EmittedService {
     readonly routes: readonly EmittedRoute[];
     /** The identifiers every per-operation validator was declared under, keyed by operation id. */
     readonly schemaNames: ReadonlyMap<string, RouteSchemaNames>;
+    /**
+     * **The identifier each declared type's validator is exported under in `schemas.gen.ts`**, keyed
+     * by the type: a model, union or enum the document publishes as a component of its own. A scalar
+     * is validated inline wherever it is used and has no entry.
+     *
+     * **Keyed by the types this service was emitted from**, which are the ones `operations` holds: a
+     * walk from an operation's response bodies, through each base's `derivedModels`, reaches the keys
+     * themselves. For a versioned service those are the types projected to its latest version, not
+     * the types as declared, which hold every version at once.
+     *
+     * **A body is keyed by the model it is, its effective payload type.** Where visibility reshapes a
+     * model, `@typespec/http` hands its body over as a copy - `Widget` returned beside a create-only
+     * property is `{ ...Widget }` - which is not a key and has no `derivedModels`. openapi3 resolves it
+     * to `Widget` with `getEffectivePayloadType`, and so does a lookup:
+     * `createMetadataInfo(program, { canonicalVisibility: Visibility.Read })
+     * .getEffectivePayloadType(body.type, Visibility.Read)`.
+     *
+     * **The declaration under the type's own component name**, which is the one a response reads
+     * wherever a response reads the type: `Widget` -> `widgetSchema`, beside a create view
+     * `widgetCreateSchema` that is not in this map. `@friendlyName` names it and a reserved word takes
+     * the module's `_`, as the module declares it: `@friendlyName("Canine") model Hound` ->
+     * `canineSchema`, `` model `default` `` -> `default_Schema`. A multipart body's model is here,
+     * validated as the form the document publishes. A type the document publishes only under views of
+     * it, sent in create and update bodies and never returned, has none.
+     *
+     * **Every subtype of a discriminated base is here**, nested bases included and whether or not an
+     * operation names it, so a wrapping emitter can tell which subtype a value is by the subtype's
+     * own validator: the base's parsed output does not say which arm of its dispatch matched.
+     *
+     * **A declaration that validates nothing has no entry** - `duplicate-declaration`,
+     * `split-visibility` and every other refusal of a whole type - so a lookup answers `undefined`
+     * rather than a validator that refuses every value.
+     *
+     * Published so that an emitter building on this one imports a declared type's validator by name
+     * rather than agreeing with this package about how the name is spelled.
+     */
+    readonly typeSchemaNames: ReadonlyMap<Type, string>;
     /**
      * **The operation each route was collected from, keyed by operation id**, so a wrapping emitter
      * reading its doc comment, tags or diagnostic target reads the right one. Verb and path do not

package/dist/src/api.js

@@ -4184,6 +4184,7 @@ export async function emitHttpZod(context) {
                 service,
                 routes,
                 schemaNames: names,
+                typeSchemaNames: registry.typeIdentifiers(),
                 operations,
                 outputDir,
                 options: resolved,

package/dist/src/registry.d.ts

@@ -119,6 +119,16 @@ export declare class SchemaRegistry {
     declareNamed(name: string, build: () => string, site: Type): string;
     /** Every declaration, dependencies first. */
     declarations(): readonly Declaration[];
+    /**
+     * **The identifier each type is declared under by its own component name** - see
+     * `EmittedService.typeSchemaNames`. That is the declaration a response reads, wherever one does:
+     * `Read` is never suffixed, so a view of the type (`WidgetCreate`) and a 3.0 request's reading of
+     * it are other declarations, and neither is the one a wrapping emitter resolves a value by. A
+     * multipart body is its model's, which the document publishes under the model's name as the form it
+     * is; an envelope is named for its union and variant, and is no type's own. A declaration that
+     * validates nothing is left out rather than published as a validator.
+     */
+    typeIdentifiers(): ReadonlyMap<Type, string>;
     /** The names of the declarations that validate nothing, refused here or in the walk beneath. */
     refusedNames(): ReadonlySet<string>;
 }

package/dist/src/registry.js

@@ -495,6 +495,8 @@ export class SchemaRegistry {
     #withheld = new Set();
     /** Every type name a refused identifier stood for: `Foo` and `foo` are both `fooSchema`. */
     #refusedTypeNames = new Set();
+    /** Each type declared by another type's declaration, the two rendered alike under one name. */
+    #alike = [];
     /**
      * Inlined types currently being walked, by identity, against the number of declarations that were
      * in flight when each was entered.
@@ -632,6 +634,9 @@ export class SchemaRegistry {
          */
         if (twin !== undefined && twin.source === declaration.source) {
             this.#declarations.set(key, twin);
+            // Another type of the name, rendered alike, is validated by it too - see `typeIdentifiers`.
+            if (twin.type !== type)
+                this.#alike.push({ type, identifier });
             return twin.identifier;
         }
         if (twin !== undefined) {
@@ -1057,6 +1062,50 @@ export class SchemaRegistry {
     declarations() {
         return this.#order;
     }
+    /**
+     * **The identifier each type is declared under by its own component name** - see
+     * `EmittedService.typeSchemaNames`. That is the declaration a response reads, wherever one does:
+     * `Read` is never suffixed, so a view of the type (`WidgetCreate`) and a 3.0 request's reading of
+     * it are other declarations, and neither is the one a wrapping emitter resolves a value by. A
+     * multipart body is its model's, which the document publishes under the model's name as the form it
+     * is; an envelope is named for its union and variant, and is no type's own. A declaration that
+     * validates nothing is left out rather than published as a validator.
+     */
+    typeIdentifiers() {
+        const found = new Map();
+        const consider = (type, declaration) => {
+            if (this.#validatesNothing(declaration))
+                return;
+            // A view, and a 3.0 request's reading, are named with a suffix - see `nameAt`.
+            const bare = declaredNameOf(this.#program, type);
+            if (bare === undefined || declaration.typeName !== safeDeclarationName(bare))
+                return;
+            found.set(type, declaration.identifier);
+        };
+        for (const declaration of this.#order) {
+            const { type, synthetic } = declaration;
+            if (type !== undefined)
+                consider(type, declaration);
+            else if (synthetic?.kind === "multipart")
+                consider(synthetic.site, declaration);
+        }
+        // By identifier, because the declaration a type shares can be rendered again since.
+        for (const { type, identifier } of this.#alike) {
+            const declaration = this.#order.find((each) => each.identifier === identifier);
+            if (declaration !== undefined)
+                consider(type, declaration);
+        }
+        return found;
+    }
+    /**
+     * **Rendered as `z.never()`, and described where it has a doc comment**, so its source is not always
+     * `UNREPRESENTABLE` itself: a model split by visibility keeps its description. A declaration refused
+     * as two shapes under one name is replaced by a bare `UNREPRESENTABLE`, so it is one of these too.
+     */
+    #validatesNothing(declaration) {
+        return (declaration.source === UNREPRESENTABLE ||
+            declaration.source.startsWith(`${UNREPRESENTABLE}.describe(`));
+    }
     /** The names of the declarations that validate nothing, refused here or in the walk beneath. */
     refusedNames() {
         return new Set([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typespec-http-zod",
-  "version": "0.32.0",
+  "version": "0.33.0",
   "description": "TypeSpec emitter and library: turn an HTTP service definition into Zod validators and framework-free contract types that agree, keyword for keyword, with the OpenAPI document @typespec/openapi3 publishes from the same source.",
   "keywords": [
     "codegen",