@ojiepermana/angular 21.3.4 → 22.0.27

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);
-    }
-}

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

@@ -1,359 +0,0 @@
-"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 types, validators
- *     metadata.ts             aggregate metadata barrel (root only)
- *     openapi-helpers.ts      metadata helpers (root only)
- *     permissions/index.ts    aggregate operation rules (root only)
- *     <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-types.ts',
-    ]);
-    if (rootShared.has(oldPath))
-        return `${SHARED}/${oldPath}`;
-    if (oldPath === 'metadata.ts' || oldPath === 'openapi-helpers.ts') {
-        return 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 oldPath;
-    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 — shared primitives + shared models only.
-    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-types';`);
-        sharedLines.push(`export * from './validators/index';`);
-        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, ''];
-        // Keep each domain entrypoint scoped to its own surface. Re-exporting the
-        // shared barrel here makes the root barrel publish the same names twice
-        // once it also exports `./shared/public-api`.
-        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.metadata) {
-            const tags = (mapping.domainServices.get(domain) ?? []).slice().sort();
-            for (const tag of tags) {
-                lines.push(`export { ${(0, template_1.camelCase)(tag)}OperationRules } from './permissions/${(0, template_1.kebabCase)(tag)}';`);
-            }
-            if (tags.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 for non-library consumers. In
-    // library mode, domain folders are real secondary entrypoints, so the root
-    // stays focused on shared/global exports and consumers deep import domains.
-    const rootLines = [target.banner, ''];
-    rootLines.push(`export * from './${SHARED}/public-api';`);
-    if (target.features.metadata) {
-        rootLines.push(`export * from './metadata';`);
-        rootLines.push(`export * from './openapi-helpers';`);
-    }
-    if (target.mode !== 'library') {
-        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

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