@ojiepermana/angular 21.0.0 → 21.0.2

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

@@ -0,0 +1,87 @@
+"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

@@ -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)(ir, 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 wrapped = applyMode(laidOut, ir, target);
+    const outputDir = (0, node_path_1.isAbsolute)(target.output) ? target.output : (0, node_path_1.resolve)(workspaceRoot, target.output);
+    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) {
+    switch (target.mode) {
+        case 'library':
+            return (0, index_1.writeLibrary)(files, ir, target);
+        case 'secondary-entrypoint':
+            return (0, index_1.writeSecondaryEntrypoint)(files, ir, target);
+        case 'standalone':
+        default:
+            return (0, index_1.writeStandalone)(files);
+    }
+}

package/generator/api/bin/src/layout/per-domain.js

@@ -0,0 +1,346 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relayoutPerDomain = relayoutPerDomain;
+/**
+ * Post-emit transform that reorganises the flat generator output into a
+ * per-domain layout:
+ *
+ * ```
+ *   <outputDir>/
+ *     shared/                 client primitives, shared models, metadata, validators
+ *     <domain>/               one folder per OpenAPI tag (kebab-cased)
+ *       models/               models only referenced by this domain
+ *       fn/                   tree-shakeable operation functions for this domain
+ *       services/             Injectable service class(es) for this domain
+ *       permissions/          per-tag permission rules
+ *       public-api.ts
+ *     public-api.ts           aggregator: re-exports shared + every domain
+ * ```
+ *
+ * The emitters themselves are not aware of the transform — they keep producing
+ * flat paths and relative imports. This module walks the emitted virtual files,
+ * rewrites their paths, and patches relative imports so everything still lines
+ * up.
+ */
+const node_path_1 = require("node:path");
+const template_1 = require("../render/template");
+const SHARED = 'shared';
+const VIRTUAL_ROOT = '/__sdk__';
+function relayoutPerDomain(files, ir, target) {
+    const mapping = computeMapping(files, ir, target);
+    // 1. Rewrite paths + relative imports, drop the original public-api.ts so we
+    //    can regenerate it with domain awareness.
+    const rewritten = [];
+    for (const file of files) {
+        if (file.path === 'public-api.ts')
+            continue;
+        const newPath = mapping.oldToNew.get(file.path);
+        if (!newPath)
+            continue;
+        rewritten.push({
+            path: newPath,
+            content: rewriteImports(file.content, file.path, newPath, mapping.oldToNew),
+        });
+    }
+    // 2. Emit per-domain + root public-api.ts.
+    rewritten.push(...emitPublicApis(ir, target, mapping));
+    return rewritten;
+}
+function computeMapping(files, ir, target) {
+    // Domain per tag. Two strategies are supported, selected by
+    // `target.splitDepth`:
+    //
+    //   'service' (default): walk each tag's `parent` chain up to the root and
+    //     use the kebab-cased root name. Every tag collapses into its owning
+    //     backend service (e.g. `Role`, `Permission`, `Role Permission` →
+    //     `access`; `Approval Definition`, `Approval Stage`, ... → `approval`;
+    //     `GCS`, `S3` → `storage`).
+    //
+    //   'tag': emit one folder per leaf tag, nested under the parent chain so
+    //     related tags stay grouped (e.g. `storage/gcs`, `storage/s3`,
+    //     `access/role`, `access/role-permission`). Tags without a parent
+    //     become a single-segment path (e.g. `auth`).
+    //
+    // In both cases the resulting string may contain `/` and is treated as a
+    // relative path. Collect operation + service lookups up front so callers
+    // can iterate without re-scanning.
+    const tagByName = new Map(ir.tags.map((t) => [t.name, t]));
+    const tagChain = (name) => {
+        const chain = [];
+        const seen = new Set();
+        let current = name;
+        while (current && !seen.has(current)) {
+            seen.add(current);
+            chain.push(current);
+            current = tagByName.get(current)?.parent;
+        }
+        return chain.reverse();
+    };
+    const domainForTag = (tag) => {
+        const chain = tagChain(tag);
+        if (chain.length === 0)
+            return SHARED;
+        if (target.splitDepth === 'tag') {
+            return (chain
+                .map((segment) => (0, template_1.kebabCase)(segment))
+                .filter(Boolean)
+                .join('/') || SHARED);
+        }
+        return (0, template_1.kebabCase)(chain[0]) || SHARED;
+    };
+    const domainOperations = new Map();
+    const domainServices = new Map();
+    const tagToDomain = new Map();
+    for (const op of ir.operations) {
+        const domain = domainForTag(op.tag);
+        tagToDomain.set(op.tag, domain);
+        const ops = domainOperations.get(domain) ?? [];
+        ops.push(op.operationId);
+        domainOperations.set(domain, ops);
+        const svcs = domainServices.get(domain) ?? [];
+        if (!svcs.includes(op.tag))
+            svcs.push(op.tag);
+        domainServices.set(domain, svcs);
+    }
+    const domains = [...domainOperations.keys()].sort();
+    // Model ownership: a model belongs to a domain only if it is exclusively
+    // referenced by that domain's operations (directly or transitively).
+    const modelDomains = new Map();
+    const markModel = (name, domain) => {
+        let set = modelDomains.get(name);
+        if (!set) {
+            set = new Set();
+            modelDomains.set(name, set);
+        }
+        set.add(domain);
+    };
+    for (const op of ir.operations) {
+        const domain = tagToDomain.get(op.tag) ?? SHARED;
+        for (const p of op.params) {
+            if (p.rule.ref)
+                markModel(p.rule.ref, domain);
+            if (p.rule.itemsRef)
+                markModel(p.rule.itemsRef, domain);
+        }
+        if (op.bodySchemaRef)
+            markModel(op.bodySchemaRef, domain);
+        if (op.successRef)
+            markModel(op.successRef, domain);
+    }
+    // Transitive closure: a model's nested refs inherit its domain set.
+    const schemaByName = new Map(ir.schemas.map((s) => [s.name, s]));
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const [name, domains] of [...modelDomains]) {
+            const schema = schemaByName.get(name);
+            if (!schema)
+                continue;
+            const refs = new Set();
+            if (schema.arrayItemRef)
+                refs.add(schema.arrayItemRef);
+            for (const rule of Object.values(schema.properties)) {
+                if (rule.ref)
+                    refs.add(rule.ref);
+                if (rule.itemsRef)
+                    refs.add(rule.itemsRef);
+            }
+            for (const ref of refs) {
+                let target = modelDomains.get(ref);
+                if (!target) {
+                    target = new Set();
+                    modelDomains.set(ref, target);
+                }
+                for (const d of domains) {
+                    if (!target.has(d)) {
+                        target.add(d);
+                        changed = true;
+                    }
+                }
+            }
+        }
+    }
+    const modelOwner = new Map();
+    for (const schema of ir.schemas) {
+        const set = modelDomains.get(schema.name);
+        if (!set || set.size !== 1)
+            modelOwner.set(schema.name, SHARED);
+        else
+            modelOwner.set(schema.name, [...set][0]);
+    }
+    // Build old → new path map.
+    const oldToNew = new Map();
+    const kebabToSchema = new Map(ir.schemas.map((s) => [(0, template_1.kebabCase)(s.name), s.name]));
+    for (const file of files) {
+        const np = computeNewPath(file.path, {
+            modelOwner,
+            kebabToSchema,
+            tagToDomain,
+        });
+        if (np)
+            oldToNew.set(file.path, np);
+    }
+    return { oldToNew, modelOwner, domains, domainOperations, domainServices };
+}
+function computeNewPath(oldPath, ctx) {
+    // Root-level client primitives → shared/.
+    const rootShared = new Set([
+        'api-configuration.ts',
+        'base-service.ts',
+        'request-builder.ts',
+        'strict-http-response.ts',
+        'api.ts',
+        'api.navigation.ts',
+        'metadata.ts',
+        'metadata-types.ts',
+        'openapi-helpers.ts',
+    ]);
+    if (rootShared.has(oldPath))
+        return `${SHARED}/${oldPath}`;
+    if (oldPath.startsWith('models/')) {
+        const kebab = oldPath.slice('models/'.length).replace(/\.ts$/, '');
+        const name = ctx.kebabToSchema.get(kebab);
+        const owner = (name && ctx.modelOwner.get(name)) || SHARED;
+        return `${owner}/models/${kebab}.ts`;
+    }
+    if (oldPath.startsWith('fn/')) {
+        // fn/<tag-kebab>/<op-kebab>.ts → <domain>/fn/<op-kebab>.ts
+        const parts = oldPath.split('/');
+        if (parts.length < 3)
+            return undefined;
+        const tagKebab = parts[1];
+        const fileName = parts.slice(2).join('/');
+        const domain = findDomainFromKebab(tagKebab, ctx.tagToDomain);
+        return `${domain}/fn/${fileName}`;
+    }
+    if (oldPath.startsWith('services/')) {
+        const fileName = oldPath.slice('services/'.length);
+        const tagKebab = fileName.replace(/\.service\.ts$/, '');
+        const domain = findDomainFromKebab(tagKebab, ctx.tagToDomain);
+        return `${domain}/services/${fileName}`;
+    }
+    if (oldPath === 'permissions/index.ts')
+        return `${SHARED}/permissions/index.ts`;
+    if (oldPath.startsWith('permissions/')) {
+        const fileName = oldPath.slice('permissions/'.length);
+        const tagKebab = fileName.replace(/\.ts$/, '');
+        const domain = findDomainFromKebab(tagKebab, ctx.tagToDomain);
+        return `${domain}/permissions/${fileName}`;
+    }
+    if (oldPath.startsWith('validators/'))
+        return `${SHARED}/${oldPath}`;
+    return undefined;
+}
+function findDomainFromKebab(tagKebab, tagToDomain) {
+    for (const [tag, domain] of tagToDomain) {
+        if ((0, template_1.kebabCase)(tag) === tagKebab)
+            return domain;
+    }
+    return tagKebab || SHARED;
+}
+function rewriteImports(content, oldPath, newPath, oldToNew) {
+    const oldAbs = node_path_1.posix.join(VIRTUAL_ROOT, oldPath);
+    const newAbs = node_path_1.posix.join(VIRTUAL_ROOT, newPath);
+    const oldDir = (0, node_path_1.dirname)(oldAbs);
+    const newDir = (0, node_path_1.dirname)(newAbs);
+    const replaceRelative = (spec) => {
+        if (!spec.startsWith('./') && !spec.startsWith('../'))
+            return spec;
+        // Resolve target old absolute (append `.ts` candidates).
+        const resolved = node_path_1.posix.normalize(node_path_1.posix.join(oldDir, spec));
+        const candidates = [`${resolved}.ts`, `${resolved}/index.ts`, resolved];
+        for (const cand of candidates) {
+            const rel = cand.startsWith(VIRTUAL_ROOT + '/') ? cand.slice(VIRTUAL_ROOT.length + 1) : null;
+            if (!rel)
+                continue;
+            const np = oldToNew.get(rel);
+            if (!np)
+                continue;
+            const targetAbs = node_path_1.posix.join(VIRTUAL_ROOT, np);
+            let nextSpec = node_path_1.posix.relative(newDir, targetAbs).replace(/\.ts$/, '');
+            if (!nextSpec.startsWith('.'))
+                nextSpec = `./${nextSpec}`;
+            return nextSpec;
+        }
+        return spec;
+    };
+    return content.replace(/(from\s+['"])([^'"]+)(['"])/g, (_m, a, spec, c) => `${a}${replaceRelative(spec)}${c}`);
+}
+function emitPublicApis(ir, target, mapping) {
+    const out = [];
+    const schemaNames = ir.schemas.map((s) => s.name);
+    // shared/public-api.ts — client primitives + shared models + metadata.
+    const sharedLines = [target.banner, ''];
+    if (target.features.client) {
+        sharedLines.push(`export { ApiConfiguration, provideApiConfiguration } from './api-configuration';`);
+        sharedLines.push(`export { BaseService } from './base-service';`);
+        sharedLines.push(`export { RequestBuilder } from './request-builder';`);
+        sharedLines.push(`export type { StrictHttpResponse } from './strict-http-response';`);
+        sharedLines.push(`export { ${target.clientName} } from './api';`);
+        sharedLines.push('');
+    }
+    if (target.features.models) {
+        const sharedModels = schemaNames.filter((n) => mapping.modelOwner.get(n) === SHARED);
+        for (const name of sharedModels) {
+            sharedLines.push(`export type { ${(0, template_1.pascalCase)(name)} } from './models/${(0, template_1.kebabCase)(name)}';`);
+        }
+        if (sharedModels.length)
+            sharedLines.push('');
+    }
+    if (target.features.metadata) {
+        sharedLines.push(`export * from './metadata';`);
+        sharedLines.push(`export * from './openapi-helpers';`);
+        sharedLines.push('');
+    }
+    if (target.features.navigation) {
+        sharedLines.push(`export { ApiNavigation } from './api.navigation';`);
+    }
+    out.push({ path: `${SHARED}/public-api.ts`, content: (0, template_1.finalize)(sharedLines.join('\n')) });
+    // Per-domain public-api.ts.
+    for (const domain of mapping.domains) {
+        const lines = [target.banner, ''];
+        // Re-export shared namespace for convenience. `domain` may be nested
+        // (e.g. `storage/gcs`), so compute the relative path instead of
+        // hard-coding `../shared/public-api`.
+        const domainDir = node_path_1.posix.join(VIRTUAL_ROOT, domain);
+        const sharedTarget = node_path_1.posix.join(VIRTUAL_ROOT, SHARED, 'public-api');
+        let sharedSpec = node_path_1.posix.relative(domainDir, sharedTarget);
+        if (!sharedSpec.startsWith('.'))
+            sharedSpec = `./${sharedSpec}`;
+        lines.push(`export * from '${sharedSpec}';`);
+        lines.push('');
+        if (target.features.models) {
+            const ownedModels = schemaNames.filter((n) => mapping.modelOwner.get(n) === domain);
+            for (const name of ownedModels) {
+                lines.push(`export type { ${(0, template_1.pascalCase)(name)} } from './models/${(0, template_1.kebabCase)(name)}';`);
+            }
+            if (ownedModels.length)
+                lines.push('');
+        }
+        if (target.features.services) {
+            const tags = mapping.domainServices.get(domain) ?? [];
+            for (const tag of tags.sort()) {
+                lines.push(`export { ${(0, template_1.pascalCase)(tag)}Service } from './services/${(0, template_1.kebabCase)(tag)}.service';`);
+            }
+            if (tags.length)
+                lines.push('');
+        }
+        if (target.features.operations) {
+            const opIds = (mapping.domainOperations.get(domain) ?? []).slice().sort();
+            for (const opId of opIds) {
+                const fnName = (0, template_1.camelCase)(opId);
+                const paramsName = `${(0, template_1.pascalCase)(opId)}$Params`;
+                lines.push(`export { ${fnName}, type ${paramsName} } from './fn/${(0, template_1.kebabCase)(opId)}';`);
+            }
+        }
+        out.push({ path: `${domain}/public-api.ts`, content: (0, template_1.finalize)(lines.join('\n')) });
+    }
+    // Root public-api.ts aggregates everything.
+    const rootLines = [target.banner, ''];
+    rootLines.push(`export * from './${SHARED}/public-api';`);
+    for (const domain of mapping.domains) {
+        rootLines.push(`export * from './${domain}/public-api';`);
+    }
+    out.push({ path: 'public-api.ts', content: (0, template_1.finalize)(rootLines.join('\n')) });
+    return out;
+}

package/generator/api/bin/src/parser/bundle.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSpec = loadSpec;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const yaml_1 = __importDefault(require("yaml"));
+/**
+ * Load an OpenAPI spec from disk. We deliberately do NOT run Swagger Parser's
+ * strict validator here because it rejects OpenAPI 3.2.x, while the rest of
+ * the pipeline only needs structural access to `components` + `paths` (which
+ * is version-stable across 3.x). Specs that rely on external `$ref`s should
+ * be bundled first with a separate tool.
+ *
+ * Accepts `.yaml`/`.yml`/`.json`.
+ */
+async function loadSpec(path) {
+    const text = (0, node_fs_1.readFileSync)(path, 'utf8');
+    const ext = (0, node_path_1.extname)(path).toLowerCase();
+    if (ext === '.json')
+        return JSON.parse(text);
+    return yaml_1.default.parse(text);
+}