svelte-reflector 2.1.5 → 2.1.7

package/dist/core/openapi/InlineSchemaPromoter.d.ts

@@ -18,6 +18,35 @@ import type { ComponentsObject, PathsObject } from "../../types/open-api-spec.in
  */
 export declare class InlineSchemaPromoter {
     static promote(components: ComponentsObject, paths: PathsObject): void;
+    /**
+     * Recursively promotes inline object and array-of-object schemas nested
+     * inside named component schemas to their own named components, replacing
+     * them with a `$ref`.
+     *
+     * The rest of the pipeline already resolves `$ref` correctly (`ObjectProp`
+     * for object properties, `ArrayProp.getType` for array items), but it
+     * silently DROPS inline objects (`SchemaPropertyClassifier.classify` returns
+     * `null` for `type: "object"` without `$ref`) and DEGRADES inline
+     * arrays-of-object to `string[]` (`array.property.ts` fallback). Promoting
+     * them upfront routes both through the working `$ref` path, producing typed
+     * child classes instead of `string[]` / dropped fields.
+     *
+     * Runs after body/response promotion so it also covers the freshly promoted
+     * envelope schemas. Uses a worklist so newly created child schemas are
+     * themselves scanned for deeper nesting.
+     */
+    private static promoteNestedObjects;
+    /** Inline object with own `properties` (not a free-form `additionalProperties` map). */
+    private static extractableInlineObject;
+    /** `type: array` whose `items` is an inline object with `properties`. */
+    private static extractableInlineArrayItems;
+    private static reserveNestedName;
+    /**
+     * OpenAPI 3.0 forbids siblings next to `$ref`, so a nullable object property
+     * must wrap the ref in `allOf` + `nullable` — the form `classifyObject`
+     * already understands. Non-nullable properties use a bare `$ref`.
+     */
+    private static refForProperty;
     private static promoteBodies;
     private static promoteInlineBody;
     private static promoteResponses;

package/dist/core/openapi/InlineSchemaPromoter.js

@@ -1,4 +1,4 @@
-import { capitalizeFirstLetter } from "../../helpers/helpers.js";
+import { capitalizeFirstLetter, isReferenceObject } from "../../helpers/helpers.js";
 const HTTP_METHODS = ["get", "put", "post", "delete", "patch", "options", "head", "trace"];
 /**
  * Promotes inline request-body and response `data` schemas to named
@@ -21,6 +21,107 @@ export class InlineSchemaPromoter {
     static promote(components, paths) {
         InlineSchemaPromoter.promoteBodies(components, paths);
         InlineSchemaPromoter.promoteResponses(components, paths);
+        InlineSchemaPromoter.promoteNestedObjects(components);
+    }
+    /**
+     * Recursively promotes inline object and array-of-object schemas nested
+     * inside named component schemas to their own named components, replacing
+     * them with a `$ref`.
+     *
+     * The rest of the pipeline already resolves `$ref` correctly (`ObjectProp`
+     * for object properties, `ArrayProp.getType` for array items), but it
+     * silently DROPS inline objects (`SchemaPropertyClassifier.classify` returns
+     * `null` for `type: "object"` without `$ref`) and DEGRADES inline
+     * arrays-of-object to `string[]` (`array.property.ts` fallback). Promoting
+     * them upfront routes both through the working `$ref` path, producing typed
+     * child classes instead of `string[]` / dropped fields.
+     *
+     * Runs after body/response promotion so it also covers the freshly promoted
+     * envelope schemas. Uses a worklist so newly created child schemas are
+     * themselves scanned for deeper nesting.
+     */
+    static promoteNestedObjects(components) {
+        const schemas = components.schemas;
+        if (!schemas)
+            return;
+        const usedNames = new Set(Object.keys(schemas));
+        const queue = Object.keys(schemas);
+        while (queue.length > 0) {
+            const schemaName = queue.shift();
+            const schema = schemas[schemaName];
+            if (!schema || "$ref" in schema)
+                continue;
+            // Array-root schema (e.g. a promoted `data: array` response): promote its
+            // inline-object items to a named `${schemaName}Item` so they get a typed
+            // child schema instead of staying inline and degrading to `string[]`.
+            if (!schema.properties && schema.type === "array") {
+                const inlineItems = InlineSchemaPromoter.extractableInlineArrayItems(schema);
+                if (inlineItems) {
+                    const name = InlineSchemaPromoter.reserveNestedName(usedNames, schemaName, "item");
+                    schemas[name] = inlineItems;
+                    queue.push(name);
+                    schema.items = { $ref: `#/components/schemas/${name}` };
+                }
+                continue;
+            }
+            if (!schema.properties)
+                continue;
+            for (const [propKey, propValue] of Object.entries(schema.properties)) {
+                if (isReferenceObject(propValue))
+                    continue;
+                const inlineObject = InlineSchemaPromoter.extractableInlineObject(propValue);
+                if (inlineObject) {
+                    const name = InlineSchemaPromoter.reserveNestedName(usedNames, schemaName, propKey);
+                    schemas[name] = inlineObject;
+                    queue.push(name);
+                    schema.properties[propKey] = InlineSchemaPromoter.refForProperty(name, propValue.nullable);
+                    continue;
+                }
+                const inlineItems = InlineSchemaPromoter.extractableInlineArrayItems(propValue);
+                if (inlineItems) {
+                    const name = InlineSchemaPromoter.reserveNestedName(usedNames, schemaName, propKey);
+                    schemas[name] = inlineItems;
+                    queue.push(name);
+                    propValue.items = { $ref: `#/components/schemas/${name}` };
+                }
+            }
+        }
+    }
+    /** Inline object with own `properties` (not a free-form `additionalProperties` map). */
+    static extractableInlineObject(value) {
+        if (value.type !== "object" || value.additionalProperties || !value.properties)
+            return null;
+        return value;
+    }
+    /** `type: array` whose `items` is an inline object with `properties`. */
+    static extractableInlineArrayItems(value) {
+        if (value.type !== "array" || !value.items || isReferenceObject(value.items))
+            return null;
+        const items = value.items;
+        if (items.type !== "object" || items.additionalProperties || !items.properties)
+            return null;
+        return items;
+    }
+    static reserveNestedName(usedNames, parent, prop) {
+        const base = `${parent}${capitalizeFirstLetter(prop.replaceAll(/[^a-zA-Z0-9]/g, ""))}`;
+        let name = base;
+        let suffix = 2;
+        while (usedNames.has(name)) {
+            name = `${base}${suffix++}`;
+        }
+        usedNames.add(name);
+        return name;
+    }
+    /**
+     * OpenAPI 3.0 forbids siblings next to `$ref`, so a nullable object property
+     * must wrap the ref in `allOf` + `nullable` — the form `classifyObject`
+     * already understands. Non-nullable properties use a bare `$ref`.
+     */
+    static refForProperty(name, nullable) {
+        const ref = { $ref: `#/components/schemas/${name}` };
+        if (nullable)
+            return { allOf: [ref], nullable: true };
+        return ref;
     }
     static promoteBodies(components, paths) {
         components.schemas ??= {};

package/dist/core/schema/ArraySchemaRenderer.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Renders the wrapper class + interface alias for an array-root schema — a
+ * component whose top level is `type: array` (e.g. a promoted `data: array`
+ * response envelope). Unlike object schemas (handled by `SchemaClassRenderer`),
+ * the interface is a bare array alias (`type XInterface = ItemInterface[]`)
+ * because the response envelope's `data` is already unwrapped: the consumer
+ * calls `new X({ data: response })` with `response` being the array itself.
+ */
+export declare class ArraySchemaRenderer {
+    static render(params: {
+        name: string;
+        elementType: string;
+        isRef: boolean;
+    }): {
+        interface: string;
+        schema: string;
+    };
+}

package/dist/core/schema/ArraySchemaRenderer.js

@@ -0,0 +1,39 @@
+/**
+ * Renders the wrapper class + interface alias for an array-root schema — a
+ * component whose top level is `type: array` (e.g. a promoted `data: array`
+ * response envelope). Unlike object schemas (handled by `SchemaClassRenderer`),
+ * the interface is a bare array alias (`type XInterface = ItemInterface[]`)
+ * because the response envelope's `data` is already unwrapped: the consumer
+ * calls `new X({ data: response })` with `response` being the array itself.
+ */
+export class ArraySchemaRenderer {
+    static render(params) {
+        const { name, elementType, isRef } = params;
+        const interfaceElement = isRef ? `${elementType}Interface` : elementType;
+        const interfaceAlias = `export type ${name}Interface = ${interfaceElement}[]`;
+        const constructorBody = isRef
+            ? `this.data = params?.data?.map((item) => new ${elementType}({ data: item })) ?? []`
+            : `this.data = params?.data ?? []`;
+        const staticBody = isRef
+            ? `return data.map((item) => new ${elementType}({ data: item }))`
+            : `return data`;
+        const bundleBody = isRef ? `return this.data.map((item) => item.bundle())` : `return this.data`;
+        const schema = `
+    export class ${name} {
+      data = $state<${elementType}[]>([]);
+
+      constructor(params?: { data?: ${name}Interface | undefined, empty?: boolean }) {
+        ${constructorBody}
+      }
+
+      static from(data: ${name}Interface) {
+        ${staticBody}
+      }
+
+      bundle(): ${name}Interface {
+        ${bundleBody}
+      }
+    };`;
+        return { interface: interfaceAlias, schema };
+    }
+}

package/dist/core/schema/Schema.d.ts

@@ -19,6 +19,27 @@ export declare class Schema {
     readonly customTypeDeps: string[];
     schema: string;
     interface: string;
+    /**
+     * Builds a Schema for an array-root component (top-level `type: array`), e.g.
+     * a promoted `data: array` response envelope. Renders a wrapper class whose
+     * `data` is `Item[]` (hydrated `new Item({ data })` when items are a `$ref`)
+     * and whose interface is a bare array alias. Object-root schemas use the
+     * regular constructor instead.
+     */
+    static forArrayRoot(params: {
+        name: string;
+        items: SchemaObject | ReferenceObject;
+        context: CodegenContext;
+    }): Schema;
+    /**
+     * Resolves the element type of an array-root schema. Inline-object items are
+     * already promoted to a `$ref` by `InlineSchemaPromoter`, so by here items is
+     * a `$ref`, an enum, a free-form object (→ `Record<string, unknown>`), or a
+     * primitive. `ArrayProp` is reused for ref/enum/primitive (it also registers
+     * the enum type in the context); the free-form object is special-cased
+     * because `ArrayProp.getType` would degrade it to `string`.
+     */
+    private static resolveArrayElement;
     constructor(params: {
         properties: Record<string, SchemaObject | ReferenceObject>;
         name: string;

package/dist/core/schema/Schema.js

@@ -2,9 +2,11 @@ import { ArrayProp } from "../../props/array.property.js";
 import { EnumProp } from "../../props/enum.property.js";
 import { ObjectProp } from "../../props/object.property.js";
 import { PrimitiveProp } from "../../props/primitive.property.js";
+import { isReferenceObject } from "../../helpers/helpers.js";
 import { SchemaPropertyClassifier } from "./SchemaPropertyClassifier.js";
 import { SchemaDependencyCollector } from "./SchemaDependencyCollector.js";
 import { SchemaClassRenderer } from "./SchemaClassRenderer.js";
+import { ArraySchemaRenderer } from "./ArraySchemaRenderer.js";
 export class Schema {
     name;
     primitiveProps = [];
@@ -19,6 +21,63 @@ export class Schema {
     customTypeDeps;
     schema;
     interface;
+    /**
+     * Builds a Schema for an array-root component (top-level `type: array`), e.g.
+     * a promoted `data: array` response envelope. Renders a wrapper class whose
+     * `data` is `Item[]` (hydrated `new Item({ data })` when items are a `$ref`)
+     * and whose interface is a bare array alias. Object-root schemas use the
+     * regular constructor instead.
+     */
+    static forArrayRoot(params) {
+        const { name, items, context } = params;
+        const element = Schema.resolveArrayElement(items, name, context);
+        const schema = Object.create(Schema.prototype);
+        schema.name = name;
+        schema.primitiveProps = [];
+        schema.arrayProps = [];
+        schema.objectProps = [];
+        schema.enumProps = [];
+        schema.schemaDeps = element.kind === "ref" ? [element.type] : [];
+        schema.enumDeps = element.kind === "enum" ? [element.type] : [];
+        schema.customTypeDeps = [];
+        const rendered = ArraySchemaRenderer.render({
+            name,
+            elementType: element.type,
+            isRef: element.kind === "ref",
+        });
+        schema.interface = rendered.interface;
+        schema.schema = rendered.schema;
+        return schema;
+    }
+    /**
+     * Resolves the element type of an array-root schema. Inline-object items are
+     * already promoted to a `$ref` by `InlineSchemaPromoter`, so by here items is
+     * a `$ref`, an enum, a free-form object (→ `Record<string, unknown>`), or a
+     * primitive. `ArrayProp` is reused for ref/enum/primitive (it also registers
+     * the enum type in the context); the free-form object is special-cased
+     * because `ArrayProp.getType` would degrade it to `string`.
+     */
+    static resolveArrayElement(items, name, context) {
+        if (isReferenceObject(items)) {
+            return { kind: "ref", type: items.$ref.split("/").at(-1) };
+        }
+        if (!items.enum && items.type === "object") {
+            return { kind: "raw", type: "Record<string, unknown>" };
+        }
+        const prop = new ArrayProp({
+            name: "data",
+            schemaObject: { type: "array", items },
+            schemaName: name,
+            required: true,
+            isParam: undefined,
+            isEnum: !!items.enum,
+            isNullable: false,
+            context,
+        });
+        if (items.enum)
+            return { kind: "enum", type: prop.type };
+        return { kind: "raw", type: prop.type };
+    }
     constructor(params) {
         const { name, isEmpty, properties, requireds, fieldConfigs, context } = params;
         this.name = `${isEmpty ? "Empty" : ""}${name}`;

package/dist/core/schema/SchemaRegistry.js

@@ -10,7 +10,13 @@ export class SchemaRegistry {
         if (!componentSchemas)
             return;
         for (const [key, object] of Object.entries(componentSchemas)) {
-            if (isReferenceObject(object) || !object.properties)
+            if (isReferenceObject(object))
+                continue;
+            if (object.type === "array" && object.items) {
+                this.schemas.push(Schema.forArrayRoot({ name: key, items: object.items, context }));
+                continue;
+            }
+            if (!object.properties)
                 continue;
             const properties = object.properties;
             const schema = {

package/dist/props/primitive.property.js

@@ -69,7 +69,10 @@ export class PrimitiveProp {
             };
         if (type === "string")
             return {
-                example: `"${example}"`,
+                // JSON.stringify escapes embedded quotes/backslashes/newlines so a
+                // string example like `{"64":true}` doesn't emit invalid JS. For
+                // plain strings the output is identical to `"${example}"`.
+                example: JSON.stringify(String(example)),
                 emptyExample,
             };
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-reflector",
-  "version": "2.1.5",
+  "version": "2.1.7",
   "description": "Reflects zod types from openAPI schemas",
   "type": "module",
   "main": "./dist/index.js",