@ojiepermana/angular-sdk 22.0.44 → 22.0.45

package/src/layout/per-domain.js

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