@ojiepermana/angular 22.0.1 → 22.0.27

package/generator/api/bin/src/emit/operations.js

@@ -1,122 +0,0 @@
-"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/generator/api/bin/src/emit/public-api.js

@@ -1,54 +0,0 @@
-"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/generator/api/bin/src/emit/services.js

@@ -1,87 +0,0 @@
-"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)).join('\n\n');
-    return `${target.banner}
-
-import { HttpContext, HttpResponse } from '@angular/common/http';
-import { Injectable } from '@angular/core';
-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) {
-    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}`;
-    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));
-  }`;
-}

package/generator/api/bin/src/engine.js

@@ -1,65 +0,0 @@
-"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);
-    }
-}