@ojiepermana/angular-sdk 22.0.44 → 22.0.46

package/src/emit/operations.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitOperations = emitOperations;
+const template_1 = require("../render/template");
+const models_1 = require("./models");
+/**
+ * Emit one tree-shakeable operation function per operationId at
+ * `fn/<tag-kebab>/<operation-kebab>.ts`.
+ *
+ * Each file exports:
+ *   - `<operationId>$Params` interface
+ *   - `<operationId>` function returning `Observable<StrictHttpResponse<R>>`
+ *   - `<operationId>.PATH` constant
+ */
+function emitOperations(ir, target) {
+    return ir.operations.map((op) => ({
+        path: `fn/${(0, template_1.kebabCase)(op.tag)}/${(0, template_1.kebabCase)(op.operationId)}.ts`,
+        content: (0, template_1.finalize)(renderOperation(op, target)),
+    }));
+}
+function renderOperation(op, target) {
+    const fnName = (0, template_1.camelCase)(op.operationId);
+    const paramsName = `${(0, template_1.pascalCase)(op.operationId)}$Params`;
+    const responseType = op.successRef ? (0, template_1.pascalCase)(op.successRef) : 'unknown';
+    const paramImports = collectParamImports(op);
+    const imports = [
+        `import { HttpClient, HttpContext, HttpResponse } from '@angular/common/http';`,
+        `import { Observable } from 'rxjs';`,
+        `import { filter, map } from 'rxjs/operators';`,
+        ``,
+        `import { RequestBuilder } from '../../request-builder';`,
+        `import { StrictHttpResponse } from '../../strict-http-response';`,
+    ];
+    for (const name of paramImports) {
+        imports.push(`import type { ${(0, template_1.pascalCase)(name)} } from '../../models/${(0, template_1.kebabCase)(name)}';`);
+    }
+    const paramsInterface = renderParamsInterface(op, paramsName);
+    const hasAnyParams = paramsInterface.hasAnyField;
+    const paramsOptional = !paramsInterface.anyRequired;
+    const bodyCT = op.bodySchemaRef ? "'application/json'" : '';
+    const pathCalls = op.params
+        .filter((p) => p.in === 'path')
+        .map((p) => `    rb.path('${p.name}', params.${safeProp(p.name)});`);
+    const queryCalls = op.params
+        .filter((p) => p.in === 'query')
+        .map((p) => `    rb.query('${p.name}', params.${safeProp(p.name)});`);
+    const headerCalls = op.params
+        .filter((p) => p.in === 'header')
+        .map((p) => `    rb.header('${p.name}', params.${safeProp(p.name)});`);
+    const bodyCall = op.bodySchemaRef ? `    rb.body(params.body, ${bodyCT});` : '';
+    const populate = pathCalls.length || queryCalls.length || headerCalls.length || bodyCall
+        ? `  if (params) {
+${[...pathCalls, ...queryCalls, ...headerCalls, bodyCall].filter(Boolean).join('\n')}
+  }`
+        : '';
+    const paramsArg = hasAnyParams
+        ? `params${paramsOptional ? '?' : ''}: ${paramsName}`
+        : `_params?: Record<string, never>`;
+    return `${target.banner}
+
+${imports.join('\n')}
+
+${paramsInterface.source}
+export function ${fnName}(
+  http: HttpClient,
+  rootUrl: string,
+  ${paramsArg},
+  context?: HttpContext,
+): Observable<StrictHttpResponse<${responseType}>> {
+  const rb = new RequestBuilder(rootUrl, ${fnName}.PATH, '${op.method}');
+${populate}
+  return http.request(rb.build({ responseType: 'json', accept: 'application/json', context })).pipe(
+    filter((r: unknown): r is HttpResponse<unknown> => r instanceof HttpResponse),
+    map((r) => r as StrictHttpResponse<${responseType}>),
+  );
+}
+
+${fnName}.PATH = '${op.path}';
+`;
+}
+function collectParamImports(op) {
+    const set = new Set();
+    for (const p of op.params) {
+        if (p.rule.ref)
+            set.add(p.rule.ref);
+        if (p.rule.itemsRef)
+            set.add(p.rule.itemsRef);
+    }
+    if (op.bodySchemaRef)
+        set.add(op.bodySchemaRef);
+    if (op.successRef)
+        set.add(op.successRef);
+    return [...set].sort();
+}
+function renderParamsInterface(op, paramsName) {
+    const lines = [];
+    let anyRequired = false;
+    const pushField = (p) => {
+        const optional = p.required ? '' : '?';
+        if (p.required)
+            anyRequired = true;
+        const type = (0, models_1.renderFieldType)(p.rule);
+        const name = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(p.name) ? p.name : `'${p.name}'`;
+        lines.push(`  ${name}${optional}: ${type};`);
+    };
+    for (const p of op.params)
+        pushField(p);
+    if (op.bodySchemaRef) {
+        const optional = op.bodyRequired ? '' : '?';
+        if (op.bodyRequired)
+            anyRequired = true;
+        lines.push(`  body${optional}: ${(0, template_1.pascalCase)(op.bodySchemaRef)};`);
+    }
+    const hasAnyField = lines.length > 0;
+    const source = hasAnyField
+        ? `export interface ${paramsName} {\n${lines.join('\n')}\n}\n`
+        : `export type ${paramsName} = Record<string, never>;\n`;
+    return { source, hasAnyField, anyRequired };
+}
+function safeProp(name) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : `['${name}']`;
+}

package/src/emit/public-api.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitPublicApi = emitPublicApi;
+const template_1 = require("../render/template");
+/**
+ * Emit `public-api.ts` — the barrel that re-exports every generated artifact
+ * based on the resolved feature flags. Mirrors the convention used by the
+ * reference output in `old/api/index.ts`.
+ */
+function emitPublicApi(ir, target) {
+    const lines = [target.banner, ''];
+    if (target.features.client) {
+        lines.push(`export { ApiConfiguration, provideApiConfiguration } from './api-configuration';`);
+        lines.push(`export { BaseService } from './base-service';`);
+        lines.push(`export { RequestBuilder } from './request-builder';`);
+        lines.push(`export type { StrictHttpResponse } from './strict-http-response';`);
+        lines.push(`export { ${target.clientName} } from './api';`);
+        lines.push('');
+    }
+    if (target.features.models) {
+        for (const schema of ir.schemas) {
+            lines.push(`export type { ${(0, template_1.pascalCase)(schema.name)} } from './models/${(0, template_1.kebabCase)(schema.name)}';`);
+        }
+        lines.push('');
+    }
+    if (target.features.services) {
+        const tags = Array.from(new Set(ir.operations.map((o) => o.tag))).sort();
+        for (const tag of tags) {
+            lines.push(`export { ${(0, template_1.pascalCase)(tag)}Service } from './services/${(0, template_1.kebabCase)(tag)}.service';`);
+        }
+        lines.push('');
+    }
+    if (target.features.operations) {
+        const sorted = [...ir.operations].sort((a, b) => a.operationId.localeCompare(b.operationId));
+        for (const op of sorted) {
+            lines.push(renderFnReexport(op));
+        }
+        lines.push('');
+    }
+    if (target.features.metadata) {
+        lines.push(`export * from './metadata';`);
+        lines.push(`export * from './openapi-helpers';`);
+        lines.push('');
+    }
+    if (target.features.navigation) {
+        lines.push(`export { ApiNavigation } from './api.navigation';`);
+    }
+    return [{ path: 'public-api.ts', content: (0, template_1.finalize)(lines.join('\n')) }];
+}
+function renderFnReexport(op) {
+    const fnName = (0, template_1.camelCase)(op.operationId);
+    const paramsName = `${(0, template_1.pascalCase)(op.operationId)}$Params`;
+    return `export { ${fnName}, type ${paramsName} } from './fn/${(0, template_1.kebabCase)(op.tag)}/${(0, template_1.kebabCase)(op.operationId)}';`;
+}

package/src/emit/services.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitServices = emitServices;
+const template_1 = require("../render/template");
+/**
+ * Emit one Injectable service per tag at `services/<tag-kebab>.service.ts`.
+ *
+ * Each method returns `Observable<T>` (body-only) plus a `<method>$Response`
+ * variant that returns the full `StrictHttpResponse<T>`. Bodies are dispatched
+ * through the tree-shakeable fn modules emitted by {@link emitOperations}, so
+ * unused methods can be shaken out.
+ */
+function emitServices(ir, target) {
+    const byTag = groupByTag(ir.operations);
+    const files = [];
+    for (const [tag, ops] of byTag) {
+        files.push({
+            path: `services/${(0, template_1.kebabCase)(tag)}.service.ts`,
+            content: (0, template_1.finalize)(renderService(tag, ops, target)),
+        });
+    }
+    return files;
+}
+function groupByTag(operations) {
+    const map = new Map();
+    for (const op of operations) {
+        const bucket = map.get(op.tag) ?? [];
+        bucket.push(op);
+        map.set(op.tag, bucket);
+    }
+    return map;
+}
+function renderService(tag, ops, target) {
+    const className = `${(0, template_1.pascalCase)(tag)}Service`;
+    const sorted = [...ops].sort((a, b) => a.operationId.localeCompare(b.operationId));
+    const fnImports = [];
+    const modelImports = new Set();
+    for (const op of sorted) {
+        const fnName = (0, template_1.camelCase)(op.operationId);
+        const paramsName = `${(0, template_1.pascalCase)(op.operationId)}$Params`;
+        fnImports.push(`import { ${fnName}, type ${paramsName} } from '../fn/${(0, template_1.kebabCase)(tag)}/${(0, template_1.kebabCase)(op.operationId)}';`);
+        if (op.successRef)
+            modelImports.add(op.successRef);
+    }
+    const modelImportLines = [...modelImports]
+        .sort()
+        .map((ref) => `import type { ${(0, template_1.pascalCase)(ref)} } from '../models/${(0, template_1.kebabCase)(ref)}';`);
+    const methods = sorted.map((op) => renderMethod(op, target.features.resources)).join('\n\n');
+    return `${target.banner}
+
+import { HttpContext, HttpResponse } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+${target.features.resources ? "import { rxResource } from '@angular/core/rxjs-interop';\n" : ''}import { Observable } from 'rxjs';
+import { filter, map } from 'rxjs/operators';
+
+import { BaseService } from '../base-service';
+import { StrictHttpResponse } from '../strict-http-response';
+
+${fnImports.join('\n')}
+${modelImportLines.length ? '\n' + modelImportLines.join('\n') : ''}
+
+@Injectable({ providedIn: 'root' })
+export class ${className} extends BaseService {
+${methods}
+}
+`;
+}
+function renderMethod(op, emitResources) {
+    const fnName = (0, template_1.camelCase)(op.operationId);
+    const paramsName = `${(0, template_1.pascalCase)(op.operationId)}$Params`;
+    const responseType = op.successRef ? (0, template_1.pascalCase)(op.successRef) : 'unknown';
+    const hasParams = op.params.length > 0 || Boolean(op.bodySchemaRef);
+    const anyRequired = op.params.some((p) => p.required) || (op.bodySchemaRef != null && op.bodyRequired);
+    const paramsSig = hasParams ? `params${anyRequired ? '' : '?'}: ${paramsName}` : `params?: ${paramsName}`;
+    let resourceMethod = '';
+    if (emitResources) {
+        if (hasParams) {
+            resourceMethod = `\n\n  /** Resource wrapper for ${op.summary ?? op.operationId} */
+  ${fnName}Resource(requestFn: () => ${paramsName}, context?: HttpContext) {
+    return rxResource({
+      request: requestFn,
+      loader: ({ request }) => this.${fnName}(request, context),
+    });
+  }`;
+        }
+        else {
+            resourceMethod = `\n\n  /** Resource wrapper for ${op.summary ?? op.operationId} */
+  ${fnName}Resource(context?: HttpContext) {
+    return rxResource({
+      loader: () => this.${fnName}(undefined, context),
+    });
+  }`;
+        }
+    }
+    return `  /** ${op.summary ?? op.operationId} (${op.method.toUpperCase()} ${op.path}) */
+  ${fnName}$Response(${paramsSig}, context?: HttpContext): Observable<StrictHttpResponse<${responseType}>> {
+    return ${fnName}(this.http, this.rootUrl, params as ${paramsName}, context).pipe(
+      filter((r: unknown): r is HttpResponse<unknown> => r instanceof HttpResponse),
+      map((r) => r as StrictHttpResponse<${responseType}>),
+    );
+  }
+
+  /** ${op.summary ?? op.operationId} (${op.method.toUpperCase()} ${op.path}) */
+  ${fnName}(${paramsSig}, context?: HttpContext): Observable<${responseType}> {
+    return this.${fnName}$Response(params as ${paramsName}, context).pipe(map((r) => r.body));
+  }${resourceMethod}`;
+}

package/src/engine.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generate = generate;
+const node_path_1 = require("node:path");
+const client_1 = require("./emit/client");
+const metadata_1 = require("./emit/metadata");
+const models_1 = require("./emit/models");
+const navigation_1 = require("./emit/navigation");
+const operations_1 = require("./emit/operations");
+const public_api_1 = require("./emit/public-api");
+const services_1 = require("./emit/services");
+const per_domain_1 = require("./layout/per-domain");
+const ir_1 = require("./parser/ir");
+const bundle_1 = require("./parser/bundle");
+const index_1 = require("./writer/index");
+/**
+ * Run the generator for a single resolved target. Pure in the sense that it
+ * does **not** touch the filesystem — the caller is expected to materialize
+ * `result.files` either into an Angular schematic `Tree` or onto disk.
+ */
+async function generate(target, workspaceRoot) {
+    const specPath = (0, node_path_1.isAbsolute)(target.input) ? target.input : (0, node_path_1.resolve)(workspaceRoot, target.input);
+    const doc = await (0, bundle_1.loadSpec)(specPath);
+    const ir = (0, ir_1.buildIR)(doc);
+    const files = [];
+    if (target.features.client)
+        files.push(...(0, client_1.emitClient)(target));
+    if (target.features.models)
+        files.push(...(0, models_1.emitModels)(ir, target));
+    if (target.features.operations)
+        files.push(...(0, operations_1.emitOperations)(ir, target));
+    if (target.features.services)
+        files.push(...(0, services_1.emitServices)(ir, target));
+    if (target.features.metadata)
+        files.push(...(0, metadata_1.emitMetadata)(ir, target));
+    if (target.features.navigation)
+        files.push(...(0, navigation_1.emitNavigation)(ir, target));
+    // public-api barrel is emitted last so it sees the final feature set.
+    files.push(...(0, public_api_1.emitPublicApi)(ir, target));
+    const laidOut = target.splitByDomain ? (0, per_domain_1.relayoutPerDomain)(files, ir, target) : files;
+    const outputDir = (0, node_path_1.isAbsolute)(target.output) ? target.output : (0, node_path_1.resolve)(workspaceRoot, target.output);
+    const wrapped = applyMode(laidOut, ir, target, workspaceRoot, outputDir);
+    return {
+        target,
+        outputDir,
+        files: wrapped,
+        stats: {
+            schemas: ir.schemas.length,
+            operations: ir.operations.length,
+            tags: new Set(ir.operations.map((o) => o.tag)).size,
+            files: wrapped.length,
+        },
+    };
+}
+function applyMode(files, ir, target, workspaceRoot, outputDir) {
+    switch (target.mode) {
+        case 'library':
+            return (0, index_1.writeLibrary)(files, ir, target, workspaceRoot, outputDir);
+        case 'secondary-entrypoint':
+            return (0, index_1.writeSecondaryEntrypoint)(files, ir, target, workspaceRoot, outputDir);
+        case 'standalone':
+        default:
+            return (0, index_1.writeStandalone)(files);
+    }
+}