@appweaver/client 1.2.1 → 1.3.1

package/cjs/commands/generate-command.js

@@ -41,7 +41,9 @@ function generateCommand(program) {
         const schemaContent = await (0, utils_1.readSchemaContent)(schemaPath);
         const schemaObject = await (0, utils_1.toSchemaObject)(schemaContent);
         if (!clientOnly && !noTypes) {
-            const typesContent = await (0, generators_1.generateTypes)(schemaObject);
+            const typesContent = await (0, generators_1.generateTypes)(schemaObject, {
+                declaration: typesPath.endsWith('.d.ts')
+            });
             await formatAndWriteFile(typesPath, typesContent, typesOnly || typesPath !== clientPath);
             console.log(`Generated types to ${node_path_1.default.relative(cwd, typesPath)}`);
         }

package/cjs/constants.d.ts

@@ -8,6 +8,15 @@ export declare const CONFIG_RESOURCE_FIELD = "x-appweaver-resource";
  * The key is the enum values joined by a `|`; the value is the name of the shared type generated
  * for them. Enums that are not listed here are named after the definitions declaring them. */
 export declare const SHARED_ENUM_NAMES: Record<string, string>;
+/** Shapes an Appweaver schema repeats inline across its definitions, and the name of the shared
+ * definition each of them is hoisted into. A `$ref` names the title of the definition it points
+ * to, since the keys the definitions are generated under vary per document. The shapes are
+ * matched in the order they are declared, so an outer shape is hoisted before the shapes nested
+ * inside it (i.e. `QueryFilterValue` before the `QueryFilterScalar` it is built from). */
+export declare const SHARED_SCHEMA_SHAPES: {
+    name: string;
+    schema: unknown;
+}[];
 /** Suffix used when generating the TypeScript module type name for a resource. */
 export declare const RESOURCE_MODULE_TYPE = "ResourceModuleType";
 /** Maps CRUD operation names to HTTP methods used for matching OpenAPI paths to `ResourceClient` methods. */

package/cjs/constants.js

@@ -3,7 +3,7 @@
 // They are typically only modified when changes occur in other Appweaver packages
 // (such as core and common) to reflect new route paths or methods.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FILE_OPERATIONS = exports.HEALTH_TYPES = exports.HEALTH_OPERATIONS = exports.HEALTH_MODULE_TYPE = exports.ACCOUNT_TYPES = exports.ACCOUNT_OPERATIONS = exports.ACCOUNT_MODULE_TYPE = exports.AUTH_TYPES = exports.AUTH_OPERATIONS = exports.AUTH_MODULE_TYPE = exports.RESOURCE_TYPES = exports.RESOURCE_OPERATIONS = exports.RESOURCE_MODULE_TYPE = exports.SHARED_ENUM_NAMES = exports.CONFIG_RESOURCE_FIELD = exports.CONFIG_FIELD = exports.FRAMEWORKS = void 0;
+exports.FILE_OPERATIONS = exports.HEALTH_TYPES = exports.HEALTH_OPERATIONS = exports.HEALTH_MODULE_TYPE = exports.ACCOUNT_TYPES = exports.ACCOUNT_OPERATIONS = exports.ACCOUNT_MODULE_TYPE = exports.AUTH_TYPES = exports.AUTH_OPERATIONS = exports.AUTH_MODULE_TYPE = exports.RESOURCE_TYPES = exports.RESOURCE_OPERATIONS = exports.RESOURCE_MODULE_TYPE = exports.SHARED_SCHEMA_SHAPES = exports.SHARED_ENUM_NAMES = exports.CONFIG_RESOURCE_FIELD = exports.CONFIG_FIELD = exports.FRAMEWORKS = void 0;
 /** Supported frameworks for generating the client class. */
 exports.FRAMEWORKS = ['fetch', 'angular'];
 /** Custom OpenAPI extension key used for extracting route prefixes and base paths to their resources. */
@@ -16,6 +16,33 @@ exports.CONFIG_RESOURCE_FIELD = 'x-appweaver-resource';
 exports.SHARED_ENUM_NAMES = {
     'asc|desc': 'SortDirection'
 };
+/** The primitive types a plain filter value takes, as an Appweaver schema declares them. */
+const FILTER_SCALAR = {
+    anyOf: [
+        { type: 'string' },
+        { type: 'number' },
+        { type: 'boolean' },
+        { type: 'null' }
+    ]
+};
+/** Shapes an Appweaver schema repeats inline across its definitions, and the name of the shared
+ * definition each of them is hoisted into. A `$ref` names the title of the definition it points
+ * to, since the keys the definitions are generated under vary per document. The shapes are
+ * matched in the order they are declared, so an outer shape is hoisted before the shapes nested
+ * inside it (i.e. `QueryFilterValue` before the `QueryFilterScalar` it is built from). */
+exports.SHARED_SCHEMA_SHAPES = [
+    {
+        name: 'QueryFilterValue',
+        schema: {
+            anyOf: [
+                FILTER_SCALAR,
+                { type: 'array', items: FILTER_SCALAR },
+                { $ref: 'QueryCondition' }
+            ]
+        }
+    },
+    { name: 'QueryFilterScalar', schema: FILTER_SCALAR }
+];
 /** Suffix used when generating the TypeScript module type name for a resource. */
 exports.RESOURCE_MODULE_TYPE = 'ResourceModuleType';
 /** Maps CRUD operation names to HTTP methods used for matching OpenAPI paths to `ResourceClient` methods. */

package/cjs/generators/generate-types.d.ts

@@ -1,9 +1,11 @@
 import { OpenAPI3 } from 'openapi-typescript';
+import { GenerateTypesOptions } from '../types';
 /**
  * Generates TypeScript types based on an OpenAPI V3 schema content.
  *
  * @param {string | OpenAPI3} schema - The OpenAPI V3 schema to generate types from. The value can be a string
  * representing JSON or YAML format, or an already parsed OpenAPI3 object.
+ * @param {GenerateTypesOptions} [options] - Options controlling how the types are emitted.
  * @return {Promise<string>} A promise that resolves to a string containing the generated TypeScript types.
  */
-export declare function generateTypes(schema: string | OpenAPI3): Promise<string>;
+export declare function generateTypes(schema: string | OpenAPI3, options?: GenerateTypesOptions): Promise<string>;

package/cjs/generators/generate-types.js

@@ -46,15 +46,16 @@ const constants_1 = require("../constants");
  *
  * @param {string | OpenAPI3} schema - The OpenAPI V3 schema to generate types from. The value can be a string
  * representing JSON or YAML format, or an already parsed OpenAPI3 object.
+ * @param {GenerateTypesOptions} [options] - Options controlling how the types are emitted.
  * @return {Promise<string>} A promise that resolves to a string containing the generated TypeScript types.
  */
-async function generateTypes(schema) {
-    // The schema is copied before the shared enums are hoisted into it, so the
-    // caller keeps the schema it passed in unchanged
+async function generateTypes(schema, options = {}) {
+    // The schema is copied before the shared definitions are hoisted into it, so
+    // the caller keeps the schema it passed in unchanged
     const schemaObject = typeof schema === 'string'
         ? await (0, utils_1.toSchemaObject)(schema)
         : structuredClone(schema);
-    const sharedEnums = (0, utils_1.hoistSharedEnums)(schemaObject);
+    const sharedTypes = (0, utils_1.hoistSharedTypes)(schemaObject);
     const ast = await (0, openapi_typescript_1.default)(schemaObject, {
         exportType: true,
         emptyObjectsUnknown: true,
@@ -91,10 +92,11 @@ async function generateTypes(schema) {
         }
     });
     let typesContent = (0, openapi_typescript_1.astToString)(deduplicateUnionConstituents(ast));
-    typesContent = extractSchemaTypes(typesContent, sharedEnums);
+    typesContent = extractSchemaTypes(typesContent, sharedTypes);
     typesContent = combineModuleTypes(typesContent, schemaObject);
     typesContent = deduplicateExportedTypes(typesContent);
-    return replaceFileUploadTypes(typesContent);
+    typesContent = replaceFileUploadTypes(typesContent);
+    return (0, utils_1.rewriteEnumsAsObjects)(typesContent, options.declaration);
 }
 /**
  * Extracts inline schema types from the generated `schemas` block.
@@ -108,12 +110,16 @@ async function generateTypes(schema) {
  *
  * And replaces the inline body in `schemas` with a reference to the new type.
  *
+ * The definitions holding the schemas shared between the other definitions are lifted the
+ * same way, whether they hold an object or, as the hoisted enums and filter values do, a
+ * union of their own.
+ *
  * @param {string} typeContent - The generated TypeScript type content as a string.
- * @param {string[]} sharedEnums - The names of the definitions holding the enums shared
+ * @param {string[]} sharedTypes - The names of the definitions holding the schemas shared
  * between the other definitions, whose references are replaced by the name alone.
  * @return {string} The transformed types content with extracted schema types.
  */
-function extractSchemaTypes(typeContent, sharedEnums = []) {
+function extractSchemaTypes(typeContent, sharedTypes = []) {
     const extractedTypes = [];
     const typeNames = new Set();
     const entries = [];
@@ -179,8 +185,11 @@ function extractSchemaTypes(typeContent, sharedEnums = []) {
         }
     }
     updatedBaseContent += normalizedTypes.slice(cursor);
+    // Lift the shared definitions holding a union rather than an object, which the
+    // entries above leave in place (i.e. `QueryFilterValue: QueryFilterScalar | ...;`)
+    updatedBaseContent = extractSharedTypes(updatedBaseContent, sharedTypes, extractedTypes, typeNames);
     // Replace all cross-references like components["schemas"]["def-89"] with the type name
-    const references = new Map(sharedEnums.map((name) => [`"${name}"`, name]));
+    const references = new Map(sharedTypes.map((name) => [`"${name}"`, name]));
     for (const [defKey, typeName] of defToTypeName) {
         references.set(defKey, typeName);
     }
@@ -215,6 +224,87 @@ function extractSchemaTypes(typeContent, sharedEnums = []) {
     const mergedExtractedTypes = stripFormat(joined.replace(doubleCommentsRegex, '$1*'));
     return updatedBaseContent + '\n' + mergedExtractedTypes;
 }
+/**
+ * Lifts the shared definitions holding a type of their own out of the generated `schemas`
+ * block, so the type they hold is declared once and referenced by name everywhere else.
+ *
+ * Finds entries like:
+ *   QueryFilterValue: QueryFilterScalar | QueryFilterScalar[] | QueryCondition;
+ *
+ * Lifts each one into:
+ *   export type QueryFilterValue = QueryFilterScalar | QueryFilterScalar[] | QueryCondition;
+ *
+ * The definitions holding nothing but a reference to a type declared elsewhere, as the hoisted
+ * enums do, are left alone.
+ *
+ * @param {string} content - The generated types, with the object definitions already extracted.
+ * @param {string[]} names - The names of the shared definitions to lift.
+ * @param {string[]} extractedTypes - The extracted types, appended to for every lifted entry.
+ * @param {Set<string>} typeNames - The names already extracted, added to for every lifted entry.
+ * @return {string} The types with the body of every lifted entry replaced by its name.
+ */
+function extractSharedTypes(content, names, extractedTypes, typeNames) {
+    // The definitions live in the components block, so a property named after one of them
+    // elsewhere in the types is never mistaken for its declaration
+    const componentsStart = content.indexOf('export type components');
+    if (componentsStart < 0) {
+        return content;
+    }
+    for (const name of names) {
+        if (typeNames.has(name)) {
+            continue;
+        }
+        // The entry starts on a line of its own, optionally preceded by the JSDoc header
+        // holding the name of the definition
+        const entry = new RegExp(String.raw `\n[ \t]*(?:\/\*\*(?:(?!\*\/)[\s\S])*\*\/\s*)?${name}: `).exec(content.slice(componentsStart));
+        if (!entry) {
+            continue;
+        }
+        const start = componentsStart + entry.index + entry[0].length;
+        const end = findTypeEnd(content, start);
+        const body = content.slice(start, end).trim();
+        // A definition referencing a type declared elsewhere holds nothing to lift
+        if (!body || body === name) {
+            continue;
+        }
+        typeNames.add(name);
+        extractedTypes.push(`export type ${name} = ${body};\n`);
+        content = content.slice(0, start) + name + content.slice(end);
+    }
+    return content;
+}
+/**
+ * Finds the end of the type starting at the given index, which is the first semicolon that is
+ * not nested inside braces, brackets, parentheses or a string literal.
+ *
+ * @param {string} content - The content holding the type.
+ * @param {number} start - The index the type starts at.
+ * @return {number} The index of the semicolon terminating the type.
+ */
+function findTypeEnd(content, start) {
+    const closing = { '{': '}', '[': ']', '(': ')' };
+    const stack = [];
+    for (let i = start; i < content.length; i++) {
+        const character = content[i];
+        if (character === '"' || character === "'") {
+            i = content.indexOf(character, i + 1);
+            if (i < 0) {
+                return content.length;
+            }
+            continue;
+        }
+        if (closing[character]) {
+            stack.push(closing[character]);
+        }
+        else if (character === stack[stack.length - 1]) {
+            stack.pop();
+        }
+        else if (character === ';' && stack.length === 0) {
+            return i;
+        }
+    }
+    return content.length;
+}
 /**
  * Deduplicates and simplifies union type constituents in the provided TypeScript Abstract Syntax Tree (AST).
  * Ensures that duplicate constituents are removed and shared types across parenthesized union branches are hoisted.

package/cjs/types/generator.d.ts

@@ -0,0 +1,6 @@
+/** Options controlling how the TypeScript types are generated from an OpenAPI schema. */
+export type GenerateTypesOptions = {
+    /** Whether the types are written into a declaration (`.d.ts`) file, which holds no runtime
+     * values and so declares the enum constants instead of initializing them. (default: false) */
+    declaration?: boolean;
+};

package/cjs/types/generator.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/types/index.d.ts

@@ -1 +1,2 @@
+export * from './generator';
 export * from './routes';

package/cjs/types/index.js

@@ -14,4 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./generator"), exports);
 __exportStar(require("./routes"), exports);

package/cjs/utils/enum-util.d.ts

@@ -1,22 +1,22 @@
-import { OpenAPI3 } from 'openapi-typescript';
 /**
- * Hoists the inline enums a schema repeats across its definitions into shared definitions
- * of their own, replacing every occurrence with a reference to the hoisted definition.
+ * Rewrites the TypeScript enums of the generated types into a constant object holding the
+ * members and a type alias of their values, so both forms are accepted wherever the enum is
+ * used (i.e. `SortDirection.asc` and the plain `'asc'` literal alike).
  *
- * An Appweaver schema declares the same enum inline over and over, once per property that
- * accepts it, and each of them would otherwise become an enum of its own in the generated
- * types (i.e. a separate `asc | desc` enum for every sortable field of every resource).
+ * A TypeScript `enum` declares a nominal type, which rejects the very literals it is built
+ * from, forcing users of the generated client to import the enum for a value the API
+ * documents as a string. The rewritten declaration keeps the member access working while
+ * typing the property as the union of its values:
  *
- * Only enums that are byte for byte identical are hoisted, so no property loses its
- * description, example or nullability along the way. The hoisted definition is named after
- * {@link SHARED_ENUM_NAMES} when its values are well known, and otherwise after the part
- * the declaring definitions have in common followed by the property name (i.e. `PostCreate`
- * and `PostSingle` declaring `status` give `PostStatus`). Enums whose name cannot be
- * resolved, or whose name is already taken, are left inline.
+ * ```ts
+ * export const SortDirection = { asc: 'asc', desc: 'desc' } as const;
+ * export type SortDirection = (typeof SortDirection)[keyof typeof SortDirection];
+ * ```
  *
- * The given schema is mutated in place.
- *
- * @param {OpenAPI3} schema The OpenAPI v3 schema to hoist the shared enums of.
- * @return {string[]} The names of the hoisted definitions, in the order they were created.
+ * @param {string} content The generated TypeScript types to rewrite the enums of.
+ * @param {boolean} [declaration=false] Whether the types are emitted into a declaration
+ * (`.d.ts`) file, which holds no runtime values and so declares the constant instead of
+ * initializing it.
+ * @return {string} The types with every enum declaration rewritten.
  */
-export declare function hoistSharedEnums(schema: OpenAPI3): string[];
+export declare function rewriteEnumsAsObjects(content: string, declaration?: boolean): string;

package/cjs/utils/enum-util.js

@@ -1,179 +1,59 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hoistSharedEnums = hoistSharedEnums;
-const constants_1 = require("../constants");
+exports.rewriteEnumsAsObjects = rewriteEnumsAsObjects;
 /**
- * Hoists the inline enums a schema repeats across its definitions into shared definitions
- * of their own, replacing every occurrence with a reference to the hoisted definition.
- *
- * An Appweaver schema declares the same enum inline over and over, once per property that
- * accepts it, and each of them would otherwise become an enum of its own in the generated
- * types (i.e. a separate `asc | desc` enum for every sortable field of every resource).
- *
- * Only enums that are byte for byte identical are hoisted, so no property loses its
- * description, example or nullability along the way. The hoisted definition is named after
- * {@link SHARED_ENUM_NAMES} when its values are well known, and otherwise after the part
- * the declaring definitions have in common followed by the property name (i.e. `PostCreate`
- * and `PostSingle` declaring `status` give `PostStatus`). Enums whose name cannot be
- * resolved, or whose name is already taken, are left inline.
- *
- * The given schema is mutated in place.
- *
- * @param {OpenAPI3} schema The OpenAPI v3 schema to hoist the shared enums of.
- * @return {string[]} The names of the hoisted definitions, in the order they were created.
- */
-function hoistSharedEnums(schema) {
-    const definitions = schema.components?.schemas;
-    if (!definitions) {
-        return [];
-    }
-    // Enums declared by identical schema content, keyed by that content
-    const groups = new Map();
-    for (const [key, definition] of Object.entries(definitions)) {
-        if (definition && typeof definition === 'object') {
-            const owner = definition['title'];
-            collectEnums(definition, typeof owner === 'string' ? owner : key, '', groups);
-        }
-    }
-    const takenNames = new Set(Object.keys(definitions));
-    for (const definition of Object.values(definitions)) {
-        const title = definition?.['title'];
-        if (typeof title === 'string') {
-            takenNames.add(title);
-        }
-    }
-    const hoistedNames = [];
-    for (const [content, occurrences] of groups) {
-        if (occurrences.length < 2) {
-            continue;
-        }
-        const name = resolveEnumName(JSON.parse(content), occurrences);
-        if (!name || takenNames.has(name)) {
-            continue;
-        }
-        takenNames.add(name);
-        hoistedNames.push(name);
-        definitions[name] = { title: name, ...JSON.parse(content) };
-        for (const { container, key } of occurrences) {
-            container[key] = {
-                $ref: `#/components/schemas/${name}`
-            };
-        }
-    }
-    return hoistedNames;
-}
-/**
- * Collects every inline enum declared below the given schema node into the groups map,
- * keyed by the stable serialization of the enum schema, so identical enums group together.
- *
- * @param {SchemaContainer} container The schema node to collect the enums of.
- * @param {string} owner The name of the definition the node belongs to.
- * @param {string} property The name of the property the node is declared under, if any.
- * @param {Map<string, EnumOccurrence[]>} groups The collected occurrences, grouped by content.
- */
-function collectEnums(container, owner, property, groups) {
-    const entries = Array.isArray(container)
-        ? container.map((value, index) => [index, value])
-        : Object.entries(container);
-    for (const [key, value] of entries) {
-        if (!value || typeof value !== 'object') {
-            continue;
-        }
-        // The keys of a `properties` object name the schemas below them, everything
-        // else keeps the property name of the node it was reached through
-        if (key === 'properties' && !Array.isArray(value)) {
-            const properties = value;
-            for (const name of Object.keys(properties)) {
-                visitSchema(properties, name, owner, name, groups);
-            }
-            continue;
-        }
-        visitSchema(container, key, owner, property, groups);
-    }
-}
-/**
- * Records the schema held by the container under the given key as an enum occurrence, or
- * descends into it when it declares no enum of its own.
- *
- * @param {SchemaContainer} container The container holding the schema node.
- * @param {string | number} key The key the schema node is held under.
- * @param {string} owner The name of the definition the node belongs to.
- * @param {string} property The name of the property the node is declared under, if any.
- * @param {Map<string, EnumOccurrence[]>} groups The collected occurrences, grouped by content.
- */
-function visitSchema(container, key, owner, property, groups) {
-    const node = container[key];
-    if (Array.isArray(node['enum'])) {
-        const content = stableStringify(node);
-        const occurrences = groups.get(content) ?? [];
-        occurrences.push({ container, key, owner, property });
-        groups.set(content, occurrences);
-        return;
-    }
-    collectEnums(node, owner, property, groups);
-}
-/**
- * Resolves the name of the definition an enum is hoisted into, preferring the name given to
- * its values by {@link SHARED_ENUM_NAMES} and falling back to the common part of the names of
- * the definitions declaring it, followed by the property name they all declare it under.
- *
- * @param {Record<string, unknown>} node The enum schema to resolve the name of.
- * @param {EnumOccurrence[]} occurrences The places the enum is declared in.
- * @return {string | undefined} The resolved name, or undefined when the enum has no name to
- * be hoisted under.
- */
-function resolveEnumName(node, occurrences) {
-    const values = node['enum'];
-    const knownName = constants_1.SHARED_ENUM_NAMES[values.join('|')];
-    if (knownName) {
-        return knownName;
-    }
-    const { property } = occurrences[0];
-    if (!property || occurrences.some((o) => o.property !== property)) {
-        return undefined;
-    }
-    const prefix = commonNamePrefix(occurrences.map((o) => o.owner));
-    if (!prefix) {
-        return undefined;
-    }
-    return prefix + property.charAt(0).toUpperCase() + property.slice(1);
-}
-/**
- * Resolves the longest prefix the given names share, cut at a word boundary so the result
- * stays a readable name (i.e. `HealthCheckResponse` and `HealthCheckResult` give
- * `HealthCheck` rather than `HealthCheckRes`).
- *
- * @param {string[]} names The names to find the common prefix of.
- * @return {string} The common prefix, empty when the names start with different words.
+ * Rewrites the TypeScript enums of the generated types into a constant object holding the
+ * members and a type alias of their values, so both forms are accepted wherever the enum is
+ * used (i.e. `SortDirection.asc` and the plain `'asc'` literal alike).
+ *
+ * A TypeScript `enum` declares a nominal type, which rejects the very literals it is built
+ * from, forcing users of the generated client to import the enum for a value the API
+ * documents as a string. The rewritten declaration keeps the member access working while
+ * typing the property as the union of its values:
+ *
+ * ```ts
+ * export const SortDirection = { asc: 'asc', desc: 'desc' } as const;
+ * export type SortDirection = (typeof SortDirection)[keyof typeof SortDirection];
+ * ```
+ *
+ * @param {string} content The generated TypeScript types to rewrite the enums of.
+ * @param {boolean} [declaration=false] Whether the types are emitted into a declaration
+ * (`.d.ts`) file, which holds no runtime values and so declares the constant instead of
+ * initializing it.
+ * @return {string} The types with every enum declaration rewritten.
  */
-function commonNamePrefix(names) {
-    const wordsPerName = names.map((name) => name.match(/[A-Z]+(?![a-z])|[A-Z]?[a-z0-9]+|[A-Z]/g) ?? []);
-    const words = [];
-    for (let i = 0; i < wordsPerName[0].length; i++) {
-        const word = wordsPerName[0][i];
-        if (wordsPerName.some((other) => other[i] !== word)) {
-            break;
-        }
-        words.push(word);
-    }
-    return words.join('');
+function rewriteEnumsAsObjects(content, declaration = false) {
+    return content.replace(/export enum (\w+) \{([^}]*)}/g, (match, name, body) => {
+        const members = parseEnumMembers(body);
+        if (members.length === 0) {
+            return match;
+        }
+        const values = members
+            .map(([member, value]) => declaration
+            ? `    readonly ${member}: ${value};`
+            : `    ${member}: ${value},`)
+            .join('\n');
+        const constant = declaration
+            ? `export declare const ${name}: {\n${values}\n};`
+            : `export const ${name} = {\n${values}\n} as const;`;
+        return `${constant}\nexport type ${name} = (typeof ${name})[keyof typeof ${name}];`;
+    });
 }
 /**
- * Serializes a value with its object keys sorted, so two schemas holding the same content
- * in a different key order serialize alike.
+ * Parses the members of an enum declaration body into their name and value pairs, keeping
+ * the value verbatim so a quoted member name or a numeric value survives the rewrite.
  *
- * @param {unknown} value The value to serialize.
- * @return {string} The stable JSON serialization of the value.
+ * @param {string} body The body of the enum declaration, without the enclosing braces.
+ * @return {[string, string][]} The name and value of every member, in declaration order.
  */
-function stableStringify(value) {
-    if (Array.isArray(value)) {
-        return `[${value.map(stableStringify).join(',')}]`;
-    }
-    if (value && typeof value === 'object') {
-        const entries = Object.keys(value)
-            .sort()
-            .map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`);
-        return `{${entries.join(',')}}`;
-    }
-    return JSON.stringify(value) ?? 'null';
+function parseEnumMembers(body) {
+    const members = [];
+    // A member name, quoted or not, followed by its value, which is a quoted string
+    // (holding a comma of its own or not) or a number
+    const pattern = /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|[\w$]+)\s*=\s*("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|-?[\d.]+)/g;
+    let member;
+    while ((member = pattern.exec(body)) !== null) {
+        members.push([member[1], member[2]]);
+    }
+    return members;
 }

package/cjs/utils/hoist-util.d.ts

@@ -0,0 +1,29 @@
+import { OpenAPI3 } from 'openapi-typescript';
+/**
+ * Hoists the schemas an OpenAPI document repeats inline across its definitions into shared
+ * definitions of their own, replacing every occurrence with a reference to the hoisted
+ * definition.
+ *
+ * An Appweaver schema declares the same shapes over and over, once per property that accepts
+ * them, and each of them would otherwise be spelled out again in the generated types (i.e. the
+ * `asc | desc` enum of every sortable field, or the accepted value of every filterable field of
+ * every resource). Two kinds of schema are hoisted:
+ *
+ * - The well known shapes of {@link SHARED_SCHEMA_SHAPES}, matched in the order they are
+ *   declared so an outer shape is hoisted before the shapes nested inside it.
+ * - The enums the definitions repeat, named after {@link SHARED_ENUM_NAMES} when their values
+ *   are well known, and otherwise after the part the declaring definitions have in common
+ *   followed by the property name (i.e. `PostCreate` and `PostSingle` declaring `status` give
+ *   `PostStatus`). Enums whose name cannot be resolved are left inline.
+ *
+ * Only the structure of a schema decides whether it is hoisted, and every occurrence keeps the
+ * documentation it carries, so no property loses its description or example along the way.
+ *
+ * A schema declared only once, or whose name is already taken, is left inline as well.
+ *
+ * The given schema is mutated in place.
+ *
+ * @param {OpenAPI3} schema The OpenAPI v3 schema to hoist the shared definitions of.
+ * @return {string[]} The names of the hoisted definitions, in the order they were created.
+ */
+export declare function hoistSharedTypes(schema: OpenAPI3): string[];