@ojiepermana/angular-sdk 22.0.44 → 22.0.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ojiepermana/angular-sdk",
-  "version": "22.0.44",
+  "version": "22.0.46",
   "description": "OpenAPI 3.x → Angular SDK generator (schematics + config surface) for @ojiepermana/angular.",
   "repository": {
     "type": "git",
@@ -15,7 +15,14 @@
     "@angular/core": ">=22.0.0"
   },
   "dependencies": {
-    "tslib": "^2.8.1"
+    "@angular-devkit/schematics": ">=18.0.0",
+    "semver": "^7.6.0",
+    "tslib": "^2.8.1",
+    "yaml": "^2.9.0"
+  },
+  "schematics": "./schematics/collection.json",
+  "ng-add": {
+    "save": "dependencies"
   },
   "publishConfig": {
     "access": "public",
@@ -32,6 +39,5 @@
       "types": "./types/ojiepermana-angular-sdk.d.ts",
       "default": "./fesm2022/ojiepermana-angular-sdk.mjs"
     }
-  },
-  "type": "module"
-}
+  }
+}

package/schematics/collection.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "../../../node_modules/@angular-devkit/schematics/collection-schema.json",
+  "schematics": {
+    "ng-add": {
+      "factory": "./ng-add/index#ngAdd",
+      "schema": "./ng-add/schema.json",
+      "description": "Install @ojiepermana/angular-sdk and align its peer dependencies."
+    },
+    "init": {
+      "factory": "./init/index#init",
+      "schema": "./init/schema.json",
+      "description": "Create an sdk.config.json at the workspace root."
+    },
+    "sdk": {
+      "factory": "./sdk/index#sdk",
+      "schema": "./sdk/schema.json",
+      "description": "Generate an Angular SDK from an OpenAPI spec using sdk.config.json."
+    }
+  }
+}

package/schematics/init/index.js

@@ -0,0 +1,90 @@
+"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: '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,
+            },
+        },
+    ],
+};
+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/schematics/init/schema.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "SdkInitSchema",
+  "title": "Initialize SDK generator config",
+  "type": "object",
+  "properties": {
+    "path": {
+      "type": "string",
+      "description": "Path (relative to workspace root) where the config file will be created.",
+      "default": "config/sdk.config.json"
+    },
+    "force": {
+      "type": "boolean",
+      "description": "Overwrite the file if it already exists.",
+      "default": false
+    }
+  },
+  "required": []
+}

package/schematics/ng-add/index.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ngAdd = ngAdd;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const tasks_1 = require("@angular-devkit/schematics/tasks");
+const semver_1 = require("semver");
+function ngAdd(options = {}) {
+    return (tree, context) => {
+        const manifest = loadLibraryManifest();
+        const requiredDependencies = collectRequiredDependencies(manifest);
+        if (requiredDependencies.length === 0) {
+            context.logger.warn('[ng-add] No peer dependencies were declared by @ojiepermana/angular.');
+            return;
+        }
+        const workspacePackageJson = readWorkspacePackageJson(tree);
+        workspacePackageJson.dependencies ??= {};
+        let changed = false;
+        for (const dependency of requiredDependencies) {
+            const existingDependency = findExistingDependency(workspacePackageJson, dependency.name);
+            if (existingDependency) {
+                if (shouldUpdateDependency(existingDependency.version, dependency.version)) {
+                    const section = workspacePackageJson[existingDependency.section] ?? {};
+                    section[dependency.name] = dependency.version;
+                    workspacePackageJson[existingDependency.section] = section;
+                    changed = true;
+                    context.logger.info(`[ng-add] updated ${dependency.name} from ${existingDependency.version} to ${dependency.version} in ${existingDependency.section}.`);
+                }
+                else {
+                    context.logger.info(`[ng-add] keeping existing ${dependency.name}@${existingDependency.version} from ${existingDependency.section}.`);
+                }
+                continue;
+            }
+            workspacePackageJson.dependencies[dependency.name] = dependency.version;
+            changed = true;
+            context.logger.info(`[ng-add] added ${dependency.name}@${dependency.version}.`);
+        }
+        if (!changed) {
+            context.logger.info('[ng-add] Required dependencies are already present.');
+            return;
+        }
+        workspacePackageJson.dependencies = sortSection(workspacePackageJson.dependencies);
+        writeWorkspacePackageJson(tree, workspacePackageJson);
+        if (!options.skipInstall) {
+            context.addTask(new tasks_1.NodePackageInstallTask());
+        }
+    };
+}
+/**
+ * Use the package manifest as the source of truth so ng-add stays aligned with
+ * the published peerDependencies and ng-update packageGroup metadata.
+ */
+function loadLibraryManifest() {
+    const candidates = [
+        // This package's own manifest (…/node_modules/@ojiepermana/angular-sdk/package.json)
+        // so a standalone install always resolves a manifest to read peers from.
+        (0, node_path_1.resolve)(__dirname, '../../package.json'),
+        (0, node_path_1.resolve)(__dirname, '../../../../../package.json'),
+        (0, node_path_1.resolve)(process.cwd(), 'node_modules/@ojiepermana/angular/package.json'),
+        (0, node_path_1.resolve)(process.cwd(), 'projects/angular/package.json'),
+    ];
+    for (const candidate of candidates) {
+        if (!(0, node_fs_1.existsSync)(candidate))
+            continue;
+        return JSON.parse((0, node_fs_1.readFileSync)(candidate, 'utf8'));
+    }
+    throw new Error('Could not locate the @ojiepermana/angular package manifest for ng-add.');
+}
+function collectRequiredDependencies(manifest) {
+    const peerDependencies = manifest.peerDependencies ?? {};
+    const packageGroup = normalizePackageGroup(manifest['ng-update']?.packageGroup);
+    return Object.keys(peerDependencies)
+        .sort((left, right) => left.localeCompare(right))
+        .map((name) => ({
+        name,
+        version: packageGroup[name] ?? peerDependencies[name],
+    }));
+}
+function normalizePackageGroup(packageGroup) {
+    if (!packageGroup) {
+        return {};
+    }
+    if (Array.isArray(packageGroup)) {
+        return {};
+    }
+    return packageGroup;
+}
+function readWorkspacePackageJson(tree) {
+    const buffer = tree.read('/package.json');
+    if (!buffer) {
+        throw new Error('No package.json found at the workspace root.');
+    }
+    return JSON.parse(buffer.toString('utf8'));
+}
+function writeWorkspacePackageJson(tree, packageJson) {
+    const content = `${JSON.stringify(packageJson, null, 2)}\n`;
+    if (tree.exists('/package.json')) {
+        tree.overwrite('/package.json', content);
+    }
+    else {
+        tree.create('/package.json', content);
+    }
+}
+function findExistingDependency(packageJson, dependencyName) {
+    const sections = [
+        'dependencies',
+        'devDependencies',
+        'peerDependencies',
+        'optionalDependencies',
+    ];
+    for (const section of sections) {
+        const version = packageJson[section]?.[dependencyName];
+        if (version) {
+            return { section, version };
+        }
+    }
+    return null;
+}
+function shouldUpdateDependency(existingVersion, requiredVersion) {
+    const existing = (0, semver_1.validRange)(existingVersion);
+    const required = (0, semver_1.validRange)(requiredVersion);
+    if (!existing || !required) {
+        return false;
+    }
+    const existingMinimum = (0, semver_1.minVersion)(existing);
+    const requiredMinimum = (0, semver_1.minVersion)(required);
+    if (!existingMinimum || !requiredMinimum) {
+        return false;
+    }
+    return existingMinimum.compare(requiredMinimum) < 0;
+}
+function sortSection(section) {
+    return Object.fromEntries(Object.entries(section).sort(([left], [right]) => left.localeCompare(right)));
+}

package/schematics/ng-add/schema.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "NgAddSchema",
+  "title": "@ojiepermana/angular ng-add options",
+  "type": "object",
+  "properties": {
+    "skipInstall": {
+      "type": "boolean",
+      "default": false,
+      "description": "Skip installing dependencies after updating package.json."
+    }
+  },
+  "additionalProperties": false
+}

package/schematics/sdk/index.js

@@ -0,0 +1,76 @@
+"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");
+/**
+ * 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})`);
+    removeStaleFiles(tree, workspaceRoot, result);
+    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 removeStaleFiles(tree, workspaceRoot, result) {
+    const outputRoot = normalizeTreePath(workspaceRoot, result.outputDir);
+    if (outputRoot === '/') {
+        return;
+    }
+    const nextFiles = new Set(result.files.map((file) => normalizeTreePath(workspaceRoot, (0, node_path_1.resolve)(result.outputDir, file.path))));
+    const staleFiles = [];
+    tree.getDir(outputRoot).visit((path) => {
+        if (!nextFiles.has(path)) {
+            staleFiles.push(path);
+        }
+    });
+    for (const staleFile of staleFiles) {
+        tree.delete(staleFile);
+    }
+}
+function normalizeTreePath(workspaceRoot, absolute) {
+    const rel = (0, node_path_1.relative)(workspaceRoot, absolute);
+    const posix = rel.split(/\\+/).join('/');
+    return posix.startsWith('/') ? posix : `/${posix}`;
+}

package/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.config.example.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "./node_modules/@ojiepermana/angular/generator/api/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/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/src/config/schema.js

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