@ojiepermana/angular 0.1.1 → 21.0.2

package/generator/api/bin/schematics/init/index.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+/**
+ * Default config template. The published package also ships a concrete
+ * `sdk.config.example.json`; this fallback only exists so `init` still works if
+ * the file is missing in unusual local/dev states.
+ */
+const FALLBACK_TEMPLATE = {
+    $schema: './node_modules/@ojiepermana/angular/generator/api/schematics/sdk/schema.json',
+    targets: [
+        {
+            input: './openapi.yaml',
+            output: './sdk',
+            mode: 'standalone',
+            clientName: 'Api',
+            rootUrl: 'http://127.0.0.1:8080',
+            splitByDomain: false,
+            splitDepth: 'service',
+            features: {
+                models: true,
+                operations: true,
+                services: true,
+                client: true,
+                metadata: true,
+                navigation: true,
+            },
+        },
+    ],
+};
+function init(options = {}) {
+    return (tree, context) => {
+        const workspaceRoot = process.cwd();
+        const destRelative = options.path ?? 'config/sdk.config.json';
+        const treePath = destRelative.startsWith('/') ? destRelative : `/${destRelative}`;
+        if (tree.exists(treePath) && !options.force) {
+            throw new Error(`${destRelative} already exists. Re-run with --force to overwrite.`);
+        }
+        const content = loadTemplate(workspaceRoot, destRelative);
+        const buffer = Buffer.from(content, 'utf8');
+        if (tree.exists(treePath)) {
+            tree.overwrite(treePath, buffer);
+            context.logger.info(`[sdk:init] overwrote ${destRelative}`);
+        }
+        else {
+            tree.create(treePath, buffer);
+            context.logger.info(`[sdk:init] created ${destRelative}`);
+        }
+        context.logger.info(`[sdk:init] edit targets[].input and targets[].output, then run \`${getNextCommand(workspaceRoot)}\`.`);
+    };
+}
+function loadTemplate(workspaceRoot, destRelative) {
+    const candidates = [
+        (0, node_path_1.resolve)(workspaceRoot, 'sdk.config.example.json'),
+        (0, node_path_1.resolve)(__dirname, '../../../sdk.config.example.json'),
+        (0, node_path_1.resolve)(workspaceRoot, 'projects/angular/generator/api/sdk.config.example.json'),
+    ];
+    for (const candidate of candidates) {
+        try {
+            const parsed = JSON.parse((0, node_fs_1.readFileSync)(candidate, 'utf8'));
+            parsed.$schema = resolveSchemaPath(workspaceRoot, destRelative);
+            return `${JSON.stringify(parsed, null, 2)}\n`;
+        }
+        catch {
+            // try next
+        }
+    }
+    return `${JSON.stringify({ ...FALLBACK_TEMPLATE, $schema: resolveSchemaPath(workspaceRoot, destRelative) }, null, 2)}\n`;
+}
+function resolveSchemaPath(workspaceRoot, destRelative) {
+    const prefix = relativePrefix(destRelative);
+    if ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(workspaceRoot, 'projects/angular/generator/api/schematics/sdk/schema.json'))) {
+        return `${prefix}projects/angular/generator/api/schematics/sdk/schema.json`;
+    }
+    return `${prefix}node_modules/@ojiepermana/angular/generator/api/schematics/sdk/schema.json`;
+}
+function relativePrefix(destRelative) {
+    const depth = destRelative.replace(/^\/+/, '').split('/').length - 1;
+    return depth <= 0 ? './' : '../'.repeat(depth);
+}
+function getNextCommand(workspaceRoot) {
+    if ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(workspaceRoot, 'projects/angular/collection.json'))) {
+        return 'bun run gen:sdk';
+    }
+    return 'ng generate @ojiepermana/angular:sdk';
+}

package/generator/api/bin/schematics/sdk/index.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sdk = sdk;
+const node_path_1 = require("node:path");
+const loader_1 = require("../../src/config/loader");
+const engine_1 = require("../../src/engine");
+/**
+ * Schematic factory. Reads `sdk.config.json` at the workspace root, runs the
+ * pure generator, and writes each emitted file into the Tree so
+ * `--dry-run` / `--force` behave as expected.
+ */
+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 relOutput = (0, node_path_1.relative)(workspaceRoot, 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})`);
+    for (const file of result.files) {
+        const absolute = (0, node_path_1.resolve)(result.outputDir, file.path);
+        const treePath = normalizeTreePath(workspaceRoot, absolute);
+        const buffer = Buffer.from(file.content, 'utf8');
+        if (tree.exists(treePath)) {
+            tree.overwrite(treePath, buffer);
+        }
+        else {
+            tree.create(treePath, buffer);
+        }
+    }
+}
+function normalizeTreePath(workspaceRoot, absolute) {
+    const rel = (0, node_path_1.relative)(workspaceRoot, absolute);
+    const posix = rel.split(/\\+/).join('/');
+    return posix.startsWith('/') ? posix : `/${posix}`;
+}

package/generator/api/bin/src/config/loader.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+const node_fs_1 = require("node:fs");
+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 mod = require(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/generator/api/bin/src/config/schema.js

@@ -0,0 +1,56 @@
+"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 DEFAULT_BANNER = '/* eslint-disable */\n/* Auto-generated by @ojiepermana/angular/generator/api. DO NOT EDIT. */';
+const DEFAULT_FEATURES = {
+    models: true,
+    operations: true,
+    services: true,
+    client: true,
+    metadata: true,
+    navigation: true,
+};
+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}`);
+    }
+    return {
+        input: raw.input,
+        output: raw.output,
+        mode,
+        clientName: raw.clientName ?? 'Api',
+        packageName: raw.packageName ?? '@local/sdk',
+        packageVersion: raw.packageVersion ?? '0.0.1',
+        rootUrl: raw.rootUrl,
+        features: { ...DEFAULT_FEATURES, ...(raw.features ?? {}) },
+        splitByDomain: raw.splitByDomain === true,
+        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/generator/api/bin/src/emit/client.js

@@ -0,0 +1,246 @@
+"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 default `rootUrl`.
+ */
+function emitClient(ir, target) {
+    const defaultRootUrl = target.rootUrl ?? ir.servers[0]?.url ?? '';
+    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 { Injectable, makeEnvironmentProviders, type EnvironmentProviders } from '@angular/core';
+
+@Injectable({ providedIn: 'root' })
+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 { Injectable, inject } from '@angular/core';
+
+import { ApiConfiguration } from './api-configuration';
+
+@Injectable()
+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';
+  reportProgress?: 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,
+        reportProgress: options.reportProgress,
+        context: options.context,
+      },
+    );
+  }
+}
+`;
+}
+function apiFile(target) {
+    return `${target.banner}
+
+import { HttpClient, HttpContext, HttpResponse } from '@angular/common/http';
+import { Injectable, 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.
+ */
+@Injectable({ providedIn: 'root' })
+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>),
+    );
+  }
+}
+`;
+}