@ojiepermana/angular 22.1.11 → 22.1.12

package/sdk/schematics/sdk/index.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sdk = sdk;
+exports.writeResult = writeResult;
+const node_path_1 = require("node:path");
+const loader_1 = require("../../src/config/loader");
+const engine_1 = require("../../src/engine");
+const OUTPUT_MANIFEST = '.ojiepermana-sdk-manifest.json';
+const OUTPUT_MANIFEST_VERSION = 1;
+/**
+ * Schematic factory. Reads `sdk.config.json` at the workspace root, runs the
+ * pure generator, and writes each emitted file into the Tree. Angular CLI
+ * `--dry-run` remains non-mutating; unmanaged file conflicts are never forced.
+ */
+function sdk(options = {}) {
+    return async (tree, context) => {
+        const workspaceRoot = process.cwd();
+        const configPath = options.config ?? 'config/sdk.config.json';
+        const targets = (0, loader_1.loadConfig)(configPath, workspaceRoot);
+        const selected = selectTargets(targets, options.target);
+        if (selected.length === 0) {
+            throw new Error(`No SDK targets matched "${options.target}"`);
+        }
+        for (const target of selected) {
+            const result = await (0, engine_1.generate)(target, workspaceRoot);
+            writeResult(tree, workspaceRoot, result, context);
+        }
+    };
+}
+function selectTargets(targets, selector) {
+    if (!selector)
+        return [...targets];
+    const idx = Number.parseInt(selector, 10);
+    if (!Number.isNaN(idx) && idx > 0 && idx <= targets.length) {
+        return [targets[idx - 1]];
+    }
+    const lc = selector.toLowerCase();
+    return targets.filter((t) => t.clientName.toLowerCase() === lc ||
+        t.output.toLowerCase().includes(lc) ||
+        t.packageName.toLowerCase() === lc);
+}
+function writeResult(tree, workspaceRoot, result, context) {
+    const outputRoot = validateOutputDirectory(workspaceRoot, result.outputDir);
+    const files = validateGeneratedFiles(result);
+    const relOutput = (0, node_path_1.relative)((0, node_path_1.resolve)(workspaceRoot), (0, node_path_1.resolve)(result.outputDir));
+    context.logger.info(`[sdk] ${result.target.mode} → ${relOutput} ` +
+        `(schemas=${result.stats.schemas}, operations=${result.stats.operations}, ` +
+        `tags=${result.stats.tags}, files=${result.stats.files})`);
+    const manifestPath = `${outputRoot}/${OUTPUT_MANIFEST}`;
+    const previousFiles = readManifest(tree, manifestPath);
+    const nextFiles = new Set(files.map((file) => file.path));
+    assertWritableFiles(tree, outputRoot, files, previousFiles);
+    removeStaleFiles(tree, outputRoot, previousFiles, nextFiles);
+    for (const file of files) {
+        const treePath = `${outputRoot}/${file.path}`;
+        const buffer = Buffer.from(file.content, 'utf8');
+        if (tree.exists(treePath)) {
+            tree.overwrite(treePath, buffer);
+        }
+        else {
+            tree.create(treePath, buffer);
+        }
+    }
+    const manifest = {
+        version: OUTPUT_MANIFEST_VERSION,
+        files: [...nextFiles].sort(),
+    };
+    const manifestBuffer = Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    if (tree.exists(manifestPath)) {
+        tree.overwrite(manifestPath, manifestBuffer);
+    }
+    else {
+        tree.create(manifestPath, manifestBuffer);
+    }
+}
+function validateOutputDirectory(workspaceRoot, outputDir) {
+    const workspace = (0, node_path_1.resolve)(workspaceRoot);
+    const output = (0, node_path_1.resolve)(outputDir);
+    const rel = (0, node_path_1.relative)(workspace, output);
+    if (!rel) {
+        throw new Error('SDK output must be a directory below the workspace root, not the workspace root itself.');
+    }
+    if (rel === '..' ||
+        rel.startsWith(`..${process.platform === 'win32' ? '\\' : '/'}`) ||
+        (0, node_path_1.isAbsolute)(rel)) {
+        throw new Error(`SDK output must stay inside the workspace root: "${outputDir}".`);
+    }
+    const posix = rel.split(/\\+/).join('/');
+    const protectedSegment = posix
+        .split('/')
+        .find((segment) => segment === '.git' || segment === 'node_modules');
+    if (protectedSegment) {
+        throw new Error(`SDK output cannot be written inside ${protectedSegment}.`);
+    }
+    return `/${posix}`;
+}
+function validateGeneratedFiles(result) {
+    const seen = new Set();
+    return result.files.map((file) => {
+        const path = normalizeVirtualPath(file.path);
+        if (path === OUTPUT_MANIFEST) {
+            throw new Error(`Generated SDK output cannot use the reserved path "${OUTPUT_MANIFEST}".`);
+        }
+        if (seen.has(path)) {
+            throw new Error(`Generated SDK output contains the duplicate path "${path}".`);
+        }
+        seen.add(path);
+        return { ...file, path };
+    });
+}
+function normalizeVirtualPath(path) {
+    const posix = path.replace(/\\/g, '/');
+    const segments = posix.split('/');
+    if (!posix ||
+        posix.startsWith('/') ||
+        /^[a-zA-Z]:/.test(posix) ||
+        segments.some((segment) => !segment || segment === '.' || segment === '..')) {
+        throw new Error(`Generated SDK file path must be a safe relative path: "${path}".`);
+    }
+    return posix;
+}
+function readManifest(tree, manifestPath) {
+    const content = tree.read(manifestPath);
+    if (!content)
+        return new Set();
+    let manifest;
+    try {
+        manifest = JSON.parse(content.toString('utf8'));
+    }
+    catch {
+        throw new Error(`SDK output manifest is not valid JSON: "${manifestPath}".`);
+    }
+    if (!isOutputManifest(manifest)) {
+        throw new Error(`SDK output manifest has an unsupported format: "${manifestPath}".`);
+    }
+    const files = new Set();
+    for (const file of manifest.files) {
+        const path = normalizeVirtualPath(file);
+        if (path === OUTPUT_MANIFEST || files.has(path)) {
+            throw new Error(`SDK output manifest contains an invalid or duplicate path: "${file}".`);
+        }
+        files.add(path);
+    }
+    return files;
+}
+function isOutputManifest(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const candidate = value;
+    return (candidate.version === OUTPUT_MANIFEST_VERSION &&
+        Array.isArray(candidate.files) &&
+        candidate.files.every((file) => typeof file === 'string'));
+}
+function removeStaleFiles(tree, outputRoot, previousFiles, nextFiles) {
+    for (const previousFile of previousFiles) {
+        if (nextFiles.has(previousFile))
+            continue;
+        const staleFile = `${outputRoot}/${previousFile}`;
+        if (tree.exists(staleFile)) {
+            tree.delete(staleFile);
+        }
+    }
+}
+function assertWritableFiles(tree, outputRoot, files, previousFiles) {
+    for (const file of files) {
+        const treePath = `${outputRoot}/${file.path}`;
+        if (!tree.exists(treePath) || previousFiles.has(file.path))
+            continue;
+        const nextContent = Buffer.from(file.content, 'utf8');
+        if (!tree.read(treePath)?.equals(nextContent)) {
+            throw new Error(`Refusing to overwrite unmanaged SDK output "${file.path}". ` +
+                `Move the file or add it to ${OUTPUT_MANIFEST} only if the generator owns it.`);
+        }
+    }
+}

package/sdk/schematics/sdk/schema.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "SdkGeneratorSchema",
+  "title": "Generate an Angular SDK from an OpenAPI spec",
+  "type": "object",
+  "properties": {
+    "config": {
+      "type": "string",
+      "description": "Path to sdk.config.json (defaults to ./config/sdk.config.json at workspace root).",
+      "default": "config/sdk.config.json"
+    },
+    "target": {
+      "type": "string",
+      "description": "Optional name/index of a specific target in the config to generate."
+    }
+  },
+  "required": [],
+  "additionalProperties": false
+}

package/sdk/sdk.config.example.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "./node_modules/@ojiepermana/angular/sdk/schematics/sdk/schema.json",
+  "targets": [
+    {
+      "input": "./openapi.yaml",
+      "output": "./sdk",
+      "mode": "library",
+      "clientName": "Api",
+      "packageName": "@my-scope/sdk",
+      "packageVersion": "0.0.1",
+      "rootUrl": "",
+      "splitByDomain": true,
+      "splitDepth": "service",
+      "features": {
+        "models": true,
+        "operations": true,
+        "services": true,
+        "client": true,
+        "metadata": true,
+        "navigation": true
+      }
+    }
+  ]
+}

package/sdk/src/config/loader.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+const node_fs_1 = require("node:fs");
+const node_module_1 = require("node:module");
+const node_path_1 = require("node:path");
+const schema_1 = require("./schema");
+/**
+ * Loads an SDK generator config from disk. Supports `.json` and `.js`/`.cjs`
+ * (require-based). `.ts` is intentionally not supported in the first iteration
+ * to avoid pulling an extra compile step — use `.json` or `.js` instead.
+ */
+function loadConfig(configPath, workspaceRoot) {
+    const absolute = (0, node_path_1.isAbsolute)(configPath) ? configPath : (0, node_path_1.resolve)(workspaceRoot, configPath);
+    if (!(0, node_fs_1.existsSync)(absolute)) {
+        throw new Error(`SDK config not found at ${absolute}`);
+    }
+    const ext = (0, node_path_1.extname)(absolute).toLowerCase();
+    let raw;
+    if (ext === '.json' || ext === '') {
+        const text = (0, node_fs_1.readFileSync)(absolute, 'utf8');
+        raw = JSON.parse(stripJsonComments(text));
+    }
+    else if (ext === '.js' || ext === '.cjs') {
+        const requireFromWorkspace = (0, node_module_1.createRequire)((0, node_path_1.resolve)(workspaceRoot, 'package.json'));
+        const mod = requireFromWorkspace(absolute);
+        raw = extractDefaultExport(mod);
+    }
+    else {
+        throw new Error(`Unsupported SDK config extension: ${ext} (use .json or .js)`);
+    }
+    return (0, schema_1.resolveConfig)(raw);
+}
+function extractDefaultExport(mod) {
+    if (mod && typeof mod === 'object' && 'default' in mod) {
+        return mod.default;
+    }
+    return mod;
+}
+function stripJsonComments(text) {
+    // Minimal JSONC support: strip // line comments and /* */ block comments.
+    return text.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:])\/\/.*$/gm, '$1');
+}

package/sdk/src/config/schema.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Public config shape for the SDK generator.
+ *
+ * Users place an `sdk.config.json` at the workspace root describing one or more
+ * generation targets. All paths are resolved relative to the workspace root
+ * (i.e. the directory containing the config file).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTarget = resolveTarget;
+exports.resolveConfig = resolveConfig;
+const template_1 = require("../render/template");
+const DEFAULT_BANNER = '/* eslint-disable */\n/* Auto-generated by @ojiepermana/angular/sdk. DO NOT EDIT. */';
+const DEFAULT_FEATURES = {
+    models: true,
+    operations: true,
+    services: true,
+    client: true,
+    metadata: true,
+    navigation: true,
+    resources: false,
+};
+function resolveTarget(raw) {
+    if (!raw || typeof raw !== 'object') {
+        throw new Error('Invalid target: expected object');
+    }
+    if (!raw.input)
+        throw new Error('Target is missing required "input"');
+    if (!raw.output)
+        throw new Error('Target is missing required "output"');
+    const mode = raw.mode ?? 'standalone';
+    if (!['standalone', 'library', 'secondary-entrypoint'].includes(mode)) {
+        throw new Error(`Invalid target mode: ${mode}`);
+    }
+    const splitByDomain = raw.splitByDomain ?? mode === 'library';
+    return {
+        input: raw.input,
+        output: raw.output,
+        mode,
+        clientName: (0, template_1.safeIdentifier)(raw.clientName ?? 'Api'),
+        packageName: raw.packageName ?? '@local/sdk',
+        packageVersion: raw.packageVersion ?? '0.0.1',
+        rootUrl: raw.rootUrl,
+        features: { ...DEFAULT_FEATURES, ...(raw.features ?? {}) },
+        splitByDomain,
+        splitDepth: raw.splitDepth === 'tag' ? 'tag' : 'service',
+        banner: raw.banner ?? DEFAULT_BANNER,
+    };
+}
+function resolveConfig(raw) {
+    if (!raw || typeof raw !== 'object') {
+        throw new Error('Invalid SDK config: root must be an object');
+    }
+    const cfg = raw;
+    if (!Array.isArray(cfg.targets) || cfg.targets.length === 0) {
+        throw new Error('Invalid SDK config: "targets" must be a non-empty array');
+    }
+    return cfg.targets.map(resolveTarget);
+}

package/sdk/src/emit/client.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitClient = emitClient;
+const template_1 = require("../render/template");
+/**
+ * Emit the tiny runtime client primitives:
+ *   - `api-configuration.ts`  — root-url config + provider
+ *   - `base-service.ts`        — per-service rootUrl override
+ *   - `strict-http-response.ts`— HttpResponse alias
+ *   - `request-builder.ts`     — minimal (path / query / header / body / build)
+ *   - `api.ts`                 — `Api` helper with invoke() / invoke$Response()
+ *
+ * These files are **static** — identical across specs — so we embed them as
+ * template literals rather than parsing the IR. The only dynamic bits are the
+ * banner comment and the configured default `rootUrl`.
+ */
+function emitClient(target) {
+    const defaultRootUrl = target.rootUrl ?? '';
+    return [
+        {
+            path: 'api-configuration.ts',
+            content: (0, template_1.finalize)(apiConfigurationFile(target, defaultRootUrl)),
+        },
+        { path: 'base-service.ts', content: (0, template_1.finalize)(baseServiceFile(target)) },
+        { path: 'strict-http-response.ts', content: (0, template_1.finalize)(strictResponseFile(target)) },
+        { path: 'request-builder.ts', content: (0, template_1.finalize)(requestBuilderFile(target)) },
+        { path: 'api.ts', content: (0, template_1.finalize)(apiFile(target)) },
+    ];
+}
+function apiConfigurationFile(target, rootUrl) {
+    return `${target.banner}
+
+import { Service, makeEnvironmentProviders, type EnvironmentProviders } from '@angular/core';
+
+@Service()
+export class ApiConfiguration {
+  rootUrl: string = ${JSON.stringify(rootUrl)};
+}
+
+export function provideApiConfiguration(rootUrl: string): EnvironmentProviders {
+  return makeEnvironmentProviders([
+    {
+      provide: ApiConfiguration,
+      useFactory: () => {
+        const c = new ApiConfiguration();
+        c.rootUrl = rootUrl;
+        return c;
+      },
+    },
+  ]);
+}
+`;
+}
+function baseServiceFile(target) {
+    return `${target.banner}
+
+import { HttpClient } from '@angular/common/http';
+import { Service, inject } from '@angular/core';
+
+import { ApiConfiguration } from './api-configuration';
+
+@Service()
+export class BaseService {
+  protected readonly config = inject(ApiConfiguration);
+  protected readonly http = inject(HttpClient);
+
+  private _rootUrl?: string;
+
+  get rootUrl(): string {
+    return this._rootUrl ?? this.config.rootUrl;
+  }
+  set rootUrl(url: string) {
+    this._rootUrl = url;
+  }
+}
+`;
+}
+function strictResponseFile(target) {
+    return `${target.banner}
+
+import { HttpResponse } from '@angular/common/http';
+
+export type StrictHttpResponse<T> = HttpResponse<T> & { readonly body: T };
+`;
+}
+/**
+ * Minimal request builder — intentionally drops the style/explode serializer
+ * from ng-openapi-gen's output. Covers the 99% case: path templating, simple
+ * query params (with array → repeated key), JSON body, and header params.
+ */
+function requestBuilderFile(target) {
+    return `${target.banner}
+
+import {
+  HttpContext,
+  HttpHeaders,
+  HttpParams,
+  HttpRequest,
+} from '@angular/common/http';
+
+export interface BuildOptions {
+  accept?: string;
+  responseType?: 'json' | 'text' | 'blob' | 'arraybuffer';
+  reportUploadProgress?: boolean;
+  reportDownloadProgress?: boolean;
+  context?: HttpContext;
+}
+
+export class RequestBuilder {
+  private readonly _pathParams = new Map<string, unknown>();
+  private readonly _queryParams = new Map<string, unknown>();
+  private readonly _headerParams = new Map<string, unknown>();
+  private _body: unknown = undefined;
+  private _bodyContentType: string | undefined;
+
+  constructor(
+    public readonly rootUrl: string,
+    public readonly operationPath: string,
+    public readonly method: string,
+  ) {}
+
+  path(name: string, value: unknown): void {
+    this._pathParams.set(name, value);
+  }
+
+  query(name: string, value: unknown): void {
+    this._queryParams.set(name, value);
+  }
+
+  header(name: string, value: unknown): void {
+    this._headerParams.set(name, value);
+  }
+
+  body(value: unknown, contentType = 'application/json'): void {
+    if (value instanceof Blob) {
+      this._bodyContentType = value.type;
+    } else if (value instanceof FormData) {
+      // FormData sets its own Content-Type (with boundary) — leave it alone.
+      this._bodyContentType = undefined;
+    } else {
+      this._bodyContentType = contentType;
+    }
+    this._body = value;
+  }
+
+  build<T = unknown>(options: BuildOptions = {}): HttpRequest<T> {
+    let path = this.operationPath;
+    for (const [name, value] of this._pathParams) {
+      path = path.replace(
+        '{' + name + '}',
+        encodeURIComponent(value == null ? '' : String(value)),
+      );
+    }
+
+    let params = new HttpParams();
+    for (const [name, value] of this._queryParams) {
+      if (value === undefined || value === null) continue;
+      if (Array.isArray(value)) {
+        for (const v of value) {
+          if (v !== undefined && v !== null) params = params.append(name, String(v));
+        }
+      } else {
+        params = params.append(name, String(value));
+      }
+    }
+
+    let headers = new HttpHeaders();
+    if (options.accept) headers = headers.set('Accept', options.accept);
+    for (const [name, value] of this._headerParams) {
+      if (value === undefined || value === null) continue;
+      if (Array.isArray(value)) {
+        for (const v of value) headers = headers.append(name, String(v));
+      } else {
+        headers = headers.set(name, String(value));
+      }
+    }
+    if (this._bodyContentType) {
+      headers = headers.set('Content-Type', this._bodyContentType);
+    }
+
+    return new HttpRequest<T>(
+      this.method.toUpperCase(),
+      this.rootUrl + path,
+      this._body as T,
+      {
+        params,
+        headers,
+        responseType: options.responseType,
+        reportUploadProgress: options.reportUploadProgress,
+        reportDownloadProgress: options.reportDownloadProgress,
+        context: options.context,
+      },
+    );
+  }
+}
+`;
+}
+function apiFile(target) {
+    return `${target.banner}
+
+import { HttpClient, HttpContext, HttpResponse } from '@angular/common/http';
+import { Service, inject } from '@angular/core';
+import { Observable } from 'rxjs';
+import { filter, map } from 'rxjs/operators';
+
+import { ApiConfiguration } from './api-configuration';
+import { StrictHttpResponse } from './strict-http-response';
+
+export type ApiFn<P, R> = (
+  http: HttpClient,
+  rootUrl: string,
+  params: P,
+  context?: HttpContext,
+) => Observable<StrictHttpResponse<R>>;
+
+/**
+ * Helper to invoke any tree-shakeable operation function directly.
+ */
+@Service()
+export class ${target.clientName} {
+  private readonly config = inject(ApiConfiguration);
+  private readonly http = inject(HttpClient);
+
+  private _rootUrl?: string;
+
+  get rootUrl(): string {
+    return this._rootUrl ?? this.config.rootUrl;
+  }
+  set rootUrl(url: string) {
+    this._rootUrl = url;
+  }
+
+  /** Invoke an operation function and stream the response body. */
+  invoke<P, R>(fn: ApiFn<P, R>, params: P, context?: HttpContext): Observable<R> {
+    return this.invoke$Response(fn, params, context).pipe(map((r) => r.body));
+  }
+
+  /** Invoke an operation function and stream the full HTTP response. */
+  invoke$Response<P, R>(
+    fn: ApiFn<P, R>,
+    params: P,
+    context?: HttpContext,
+  ): Observable<StrictHttpResponse<R>> {
+    return fn(this.http, this.rootUrl, params, context).pipe(
+      filter((r: unknown): r is HttpResponse<unknown> => r instanceof HttpResponse),
+      map((r) => r as StrictHttpResponse<R>),
+    );
+  }
+}
+`;
+}