@ojiepermana/angular 22.1.11 → 22.1.13

package/sdk/src/parser/ir.js

@@ -0,0 +1,429 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildIR = buildIR;
+const HTTP_METHODS = [
+    'get',
+    'post',
+    'put',
+    'patch',
+    'delete',
+    'head',
+    'options',
+];
+/**
+ * Build the Intermediate Representation from a bundled OpenAPI document.
+ *
+ * Expectations about input:
+ *  - `$ref` strings in the form `#/components/<section>/<Name>`, where the
+ *    section (`schemas`, `parameters`, `requestBodies`, `responses`) decides how
+ *    the reference is resolved.
+ *  - OpenAPI 3.0.x / 3.1.x / 3.2.x (nullable via `type: ['string', 'null']` or
+ *    `nullable: true`).
+ */
+function buildIR(doc) {
+    const root = asRecord(doc) ?? {};
+    const info = asRecord(root['info']) ?? {};
+    const components = asRecord(root['components']);
+    const servers = asArray(root['servers']).map((value) => {
+        const server = asRecord(value) ?? {};
+        return {
+            url: String(server['url'] ?? ''),
+            description: optionalString(server['description']),
+        };
+    });
+    const tags = asArray(root['tags']).map((value) => {
+        const tag = asRecord(value) ?? {};
+        return {
+            name: String(tag['name']),
+            parent: optionalString(tag['parent']),
+            kind: optionalString(tag['kind']),
+            xIcon: optionalString(tag['x-icon']),
+            description: optionalString(tag['description']),
+        };
+    });
+    const schemas = buildSchemas(components?.['schemas']);
+    const operations = buildOperations(root['paths'], components);
+    const security = buildSecuritySchemes(asRecord(components?.['securitySchemes']));
+    return {
+        title: String(info['title'] ?? 'API'),
+        version: String(info['version'] ?? '0.0.0'),
+        description: optionalString(info['description']),
+        servers,
+        tags,
+        navigation: buildNavigation(tags),
+        schemas,
+        operations,
+        security,
+    };
+}
+// ---------------------------------------------------------------------------
+// Schemas
+// ---------------------------------------------------------------------------
+function buildSchemas(rawSchemasInput) {
+    const rawSchemas = asRecord(rawSchemasInput);
+    if (!rawSchemas)
+        return [];
+    const names = Object.keys(rawSchemas).sort();
+    return names.map((name) => buildSchema(name, rawSchemas[name]));
+}
+function buildSchema(name, rawInput) {
+    const raw = asRecord(rawInput) ?? {};
+    const required = stringArray(raw['required']);
+    const properties = {};
+    // allOf: merge inline properties + required lists into the parent.
+    const mergedProps = { ...(asRecord(raw['properties']) ?? {}) };
+    for (const part of recordArray(raw['allOf'])) {
+        const partProperties = asRecord(part['properties']);
+        if (partProperties)
+            Object.assign(mergedProps, partProperties);
+        for (const requirement of stringArray(part['required'])) {
+            if (!required.includes(requirement))
+                required.push(requirement);
+        }
+    }
+    for (const [propName, propSchema] of Object.entries(mergedProps)) {
+        properties[propName] = buildFieldRule(propSchema, required.includes(propName));
+    }
+    // Primitive enum schemas emit as alias types.
+    const primitiveType = resolvePrimitiveType(raw);
+    const enumValues = literalArray(raw['enum']);
+    if (primitiveType && enumValues) {
+        return {
+            name,
+            description: optionalString(raw['description']),
+            required: [],
+            properties: {},
+            enumValues,
+        };
+    }
+    // Array alias schemas.
+    const items = asRecord(raw['items']);
+    if (resolvedTypeIs(raw, 'array') && items) {
+        const itemRef = schemaRefName(items['$ref']);
+        const itemType = itemRef ? undefined : resolvePrimitiveType(items);
+        return {
+            name,
+            description: optionalString(raw['description']),
+            required: [],
+            properties: {},
+            arrayItemRef: itemRef ?? undefined,
+            arrayItemType: itemType ?? undefined,
+        };
+    }
+    return {
+        name,
+        description: optionalString(raw['description']),
+        required,
+        properties,
+    };
+}
+function buildFieldRule(rawInput, required) {
+    const raw = asRecord(rawInput) ?? {};
+    const rule = { required };
+    // $ref -> named reference.
+    const ref = schemaRefName(raw['$ref']);
+    if (ref) {
+        rule.ref = ref;
+        return rule;
+    }
+    // Array with items.
+    const items = asRecord(raw['items']);
+    if (resolvedTypeIs(raw, 'array') && items) {
+        rule.type = 'array';
+        const itemsRef = schemaRefName(items['$ref']);
+        if (itemsRef)
+            rule.itemsRef = itemsRef;
+        else
+            rule.itemsType = resolvePrimitiveType(items) ?? 'unknown';
+        const itemEnum = literalArray(items['enum']);
+        if (itemEnum)
+            rule.enumValues = itemEnum;
+        const description = optionalString(raw['description']);
+        if (description)
+            rule.description = description;
+        rule.nullable = isNullable(raw);
+        return rule;
+    }
+    // Primitive / object.
+    rule.type = resolvePrimitiveType(raw) ?? 'unknown';
+    rule.nullable = isNullable(raw);
+    const format = optionalString(raw['format']);
+    const description = optionalString(raw['description']);
+    const pattern = optionalString(raw['pattern']);
+    const enumValues = literalArray(raw['enum']);
+    if (format)
+        rule.format = format;
+    if (description)
+        rule.description = description;
+    if (typeof raw['minLength'] === 'number')
+        rule.minLength = raw['minLength'];
+    if (typeof raw['maxLength'] === 'number')
+        rule.maxLength = raw['maxLength'];
+    if (typeof raw['minimum'] === 'number')
+        rule.minimum = raw['minimum'];
+    if (typeof raw['maximum'] === 'number')
+        rule.maximum = raw['maximum'];
+    if (pattern)
+        rule.pattern = pattern;
+    if (enumValues)
+        rule.enumValues = enumValues;
+    return rule;
+}
+function resolvePrimitiveType(rawInput) {
+    const raw = asRecord(rawInput);
+    if (!raw)
+        return undefined;
+    const type = raw['type'];
+    if (Array.isArray(type)) {
+        const nonNull = type.find((value) => typeof value === 'string' && value !== 'null');
+        return nonNull ?? undefined;
+    }
+    if (typeof type === 'string')
+        return type;
+    return undefined;
+}
+function resolvedTypeIs(raw, target) {
+    return resolvePrimitiveType(raw) === target;
+}
+function isNullable(rawInput) {
+    const raw = asRecord(rawInput);
+    if (!raw)
+        return false;
+    if (raw['nullable'] === true)
+        return true;
+    const type = raw['type'];
+    return Array.isArray(type) && type.includes('null');
+}
+/**
+ * Component references are resolved by their section, never by their last path
+ * segment: `#/components/requestBodies/CreateItemBody` names a request body,
+ * not a schema, and only `components.schemas` becomes a generated model.
+ */
+function componentRefName(ref, section) {
+    if (typeof ref !== 'string')
+        return undefined;
+    const prefix = `#/components/${section}/`;
+    return ref.startsWith(prefix) && ref.length > prefix.length
+        ? ref.slice(prefix.length)
+        : undefined;
+}
+function schemaRefName(ref) {
+    return componentRefName(ref, 'schemas');
+}
+/** Follow a `#/components/<section>/<name>` chain to the object it names. */
+function dereferenceComponent(value, section, components) {
+    const pool = asRecord(components?.[section]);
+    let record = asRecord(value);
+    const seen = new Set();
+    while (record && typeof record['$ref'] === 'string') {
+        const name = componentRefName(record['$ref'], section);
+        if (!name || seen.has(name))
+            return undefined;
+        seen.add(name);
+        record = asRecord(pool?.[name]);
+    }
+    return record;
+}
+// ---------------------------------------------------------------------------
+// Operations
+// ---------------------------------------------------------------------------
+function buildOperations(pathsInput, componentsInput) {
+    const paths = asRecord(pathsInput);
+    if (!paths)
+        return [];
+    const components = asRecord(componentsInput);
+    const operations = [];
+    for (const [pathKey, pathItemInput] of Object.entries(paths)) {
+        const pathItem = asRecord(pathItemInput);
+        if (!pathItem)
+            continue;
+        const pathLevelParams = asArray(pathItem['parameters']);
+        for (const method of HTTP_METHODS) {
+            const op = asRecord(pathItem[method]);
+            if (!op)
+                continue;
+            operations.push(buildOperation(pathKey, method, op, pathLevelParams, components));
+        }
+    }
+    return operations.sort((a, b) => a.operationId.localeCompare(b.operationId));
+}
+function buildOperation(path, method, op, pathLevelParams, components) {
+    const rawTags = stringArray(op['tags']);
+    const tags = rawTags.length ? rawTags : ['Default'];
+    const params = mergeParams(pathLevelParams, op['parameters'], asRecord(components?.['parameters']));
+    const body = dereferenceComponent(op['requestBody'], 'requestBodies', components);
+    const bodySchemaRef = jsonSchemaRef(body);
+    const responses = {};
+    let successStatus;
+    let successRef;
+    for (const [status, resp] of Object.entries(asRecord(op['responses']) ?? {})) {
+        const response = dereferenceComponent(resp, 'responses', components);
+        const ref = jsonSchemaRef(response);
+        responses[status] = ref;
+        if (!successStatus && status.startsWith('2')) {
+            successStatus = status;
+            successRef = ref;
+        }
+    }
+    const securitySchemes = [];
+    for (const security of asArray(op['security'])) {
+        const schemeRecord = asRecord(security);
+        if (!schemeRecord)
+            continue;
+        for (const key of Object.keys(schemeRecord)) {
+            if (!securitySchemes.includes(key))
+                securitySchemes.push(key);
+        }
+    }
+    const operationId = optionalString(op['operationId']) ?? synthesizeOperationId(method, path);
+    return {
+        operationId,
+        method,
+        path,
+        tag: tags[0] ?? 'Default',
+        tags,
+        summary: optionalString(op['summary']),
+        description: optionalString(op['description']),
+        params,
+        bodySchemaRef,
+        bodyRequired: body?.['required'] === true,
+        responses,
+        successStatus,
+        successRef,
+        securitySchemes,
+        requiredPermissions: stringArray(op['x-required-permissions']),
+        authorizationNotes: stringArray(op['x-authorization-notes']),
+    };
+}
+function mergeParams(pathLevelParams, opParams, sharedParams) {
+    const out = [];
+    const slotByKey = new Map();
+    const ownedByOperation = new Set();
+    // The OpenAPI specification makes an operation-level parameter override a
+    // path-level one with the same name and location, so the operation pass
+    // replaces the entry in place rather than being dropped as a duplicate. The
+    // path-level position is kept so parameter order stays stable, and the first
+    // declaration wins within each level.
+    const collect = (raws, fromOperation) => {
+        for (const raw of raws) {
+            const resolved = resolveParamRef(raw, sharedParams);
+            const name = optionalString(resolved?.['name']);
+            const rawLocation = optionalString(resolved?.['in']);
+            if (!resolved || !name || !rawLocation)
+                continue;
+            const key = `${rawLocation}:${name}`;
+            const slot = slotByKey.get(key);
+            if (slot !== undefined && (!fromOperation || ownedByOperation.has(key)))
+                continue;
+            const loc = rawLocation === 'path' || rawLocation === 'query' || rawLocation === 'header'
+                ? rawLocation
+                : 'query';
+            const param = {
+                name,
+                in: loc,
+                required: resolved['required'] === true,
+                rule: buildFieldRule(resolved['schema'] ?? {}, resolved['required'] === true),
+            };
+            if (fromOperation)
+                ownedByOperation.add(key);
+            if (slot === undefined) {
+                slotByKey.set(key, out.length);
+                out.push(param);
+            }
+            else {
+                out[slot] = param;
+            }
+        }
+    };
+    collect(pathLevelParams, false);
+    collect(asArray(opParams), true);
+    return out;
+}
+function resolveParamRef(rawInput, sharedParams) {
+    const raw = asRecord(rawInput);
+    if (!raw)
+        return undefined;
+    const ref = componentRefName(raw['$ref'], 'parameters');
+    if (!ref || !sharedParams)
+        return raw;
+    return asRecord(sharedParams[ref]) ?? raw;
+}
+function synthesizeOperationId(method, path) {
+    const cleaned = path
+        .replace(/\/+/g, '/')
+        .split('/')
+        .filter(Boolean)
+        .map((seg) => seg.replace(/^\{/, 'by-').replace(/\}$/, ''))
+        .join('-');
+    return `${method}-${cleaned || 'root'}`;
+}
+function jsonSchemaRef(value) {
+    const record = asRecord(value);
+    const content = asRecord(record?.['content']);
+    const json = asRecord(content?.['application/json']);
+    const schema = asRecord(json?.['schema']);
+    return schemaRefName(schema?.['$ref']);
+}
+// ---------------------------------------------------------------------------
+// Security & navigation
+// ---------------------------------------------------------------------------
+function buildSecuritySchemes(raw) {
+    if (!raw)
+        return [];
+    return Object.entries(raw).map(([name, value]) => {
+        const scheme = asRecord(value) ?? {};
+        return {
+            name,
+            type: String(scheme['type'] ?? 'unknown'),
+            scheme: optionalString(scheme['scheme']),
+            bearerFormat: optionalString(scheme['bearerFormat']),
+            in: optionalString(scheme['in']),
+        };
+    });
+}
+function buildNavigation(tags) {
+    const byName = new Map();
+    for (const t of tags) {
+        byName.set(t.name, { name: t.name, xIcon: t.xIcon, description: t.description, children: [] });
+    }
+    const roots = [];
+    for (const t of tags) {
+        const node = byName.get(t.name);
+        if (t.parent && byName.has(t.parent)) {
+            byName.get(t.parent).children.push(node);
+        }
+        else {
+            roots.push(node);
+        }
+    }
+    return roots;
+}
+function asRecord(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function recordArray(value) {
+    return asArray(value).flatMap((item) => {
+        const record = asRecord(item);
+        return record ? [record] : [];
+    });
+}
+function stringArray(value) {
+    return asArray(value).map(String);
+}
+function optionalString(value) {
+    return value == null ? undefined : String(value);
+}
+function literalArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const literals = value.filter((item) => {
+        return typeof item === 'string' || typeof item === 'number';
+    });
+    return literals.length ? literals : undefined;
+}

package/sdk/src/parser/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * Intermediate Representation (IR) that emitters consume. Keeping this thin +
+ * plain-object makes emitters trivial to unit test without pulling in an OpenAPI
+ * parser in the test path.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/sdk/src/render/template.js

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * Tiny rendering helpers. We use template literals + small utilities rather
+ * than a template engine to keep the generator dependency-free and the
+ * emitter output predictable.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kebabCase = kebabCase;
+exports.pascalCase = pascalCase;
+exports.camelCase = camelCase;
+exports.safeIdentifier = safeIdentifier;
+exports.quote = quote;
+exports.propertyKey = propertyKey;
+exports.propertyAccess = propertyAccess;
+exports.finalize = finalize;
+exports.comment = comment;
+exports.joinBlocks = joinBlocks;
+/** kebab-case (preserving digits) — matches the naming style in `old/api/`. */
+function kebabCase(input) {
+    return String(input)
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
+        .replace(/[^a-zA-Z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase();
+}
+/** PascalCase — used for class/interface names when sanitizing tags. */
+function pascalCase(input) {
+    const words = String(input)
+        .replace(/[^a-zA-Z0-9]+/g, ' ')
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean)
+        .map((w) => w[0].toUpperCase() + w.slice(1))
+        .join('');
+    return words ? safeIdentifier(words) : '';
+}
+/** camelCase — used for variable / method / fn names. */
+function camelCase(input) {
+    const pc = pascalCase(input);
+    return pc ? safeIdentifier(pc[0].toLowerCase() + pc.slice(1)) : '';
+}
+/**
+ * Reserved words plus the identifiers a strict-mode module may not bind. An
+ * `operationId` is arbitrary text from the OpenAPI document, so `delete` or
+ * `2faVerify` reach the emitters as-is and would otherwise be written straight
+ * into `export function <name>(`.
+ */
+const RESERVED_WORDS = new Set([
+    'arguments',
+    'await',
+    'break',
+    'case',
+    'catch',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'else',
+    'enum',
+    'eval',
+    'export',
+    'extends',
+    'false',
+    'finally',
+    'for',
+    'function',
+    'if',
+    'implements',
+    'import',
+    'in',
+    'instanceof',
+    'interface',
+    'let',
+    'new',
+    'null',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'return',
+    'static',
+    'super',
+    'switch',
+    'this',
+    'throw',
+    'true',
+    'try',
+    'typeof',
+    'undefined',
+    'var',
+    'void',
+    'while',
+    'with',
+    'yield',
+]);
+/**
+ * Make an unquoted identifier legal: prefix a leading digit, suffix a reserved
+ * word. Every generated function, class, interface and variable name goes
+ * through here, so a name and every reference to it stay in step.
+ */
+function safeIdentifier(name) {
+    const prefixed = /^[0-9]/.test(name) ? `_${name}` : name;
+    return RESERVED_WORDS.has(prefixed) ? `${prefixed}_` : prefixed;
+}
+const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+/**
+ * A single-quoted TypeScript string literal. Every quoted identifier the
+ * emitters produce must go through here — a schema property, a parameter name,
+ * or a path template is arbitrary text from the OpenAPI document, and an
+ * apostrophe in it would otherwise close the literal and emit broken source.
+ */
+function quote(value) {
+    const escaped = String(value)
+        .replace(/\\/g, '\\\\')
+        .replace(/'/g, "\\'")
+        .replace(/\r/g, '\\r')
+        .replace(/\n/g, '\\n');
+    return `'${escaped}'`;
+}
+/** A property key for an interface or object literal — bare when safe, quoted otherwise. */
+function propertyKey(name) {
+    return IDENTIFIER.test(name) ? name : quote(name);
+}
+/** A property access suffix — dotted when safe, bracketed otherwise. */
+function propertyAccess(name) {
+    return IDENTIFIER.test(name) ? `.${name}` : `[${quote(name)}]`;
+}
+/** Trim trailing whitespace on every line and ensure a single trailing newline. */
+function finalize(text) {
+    const trimmed = text
+        .split('\n')
+        .map((line) => line.replace(/\s+$/g, ''))
+        .join('\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .replace(/^\s*\n/, '');
+    return trimmed.endsWith('\n') ? trimmed : trimmed + '\n';
+}
+/** Render an indented block-comment (1-line friendly). */
+function comment(text) {
+    if (!text)
+        return '';
+    const safe = text.replace(/\*\//g, '*\\/');
+    return `/** ${safe} */`;
+}
+/** Join non-empty blocks with a blank line between them. */
+function joinBlocks(blocks) {
+    return blocks.filter(Boolean).join('\n\n');
+}