@ldsg/cli 0.3.29 → 0.3.30

package/src/__tests__/source-resolver.test.ts

@@ -0,0 +1,125 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { resolveSource, isStdinSource, getSourceDescription } from '../utils/source-resolver';
+
+jest.mock('fs-extra');
+
+const mockedFs = fs as jest.Mocked<typeof fs> & {
+  pathExists: jest.Mock;
+  readJson: jest.Mock;
+  stat: jest.Mock;
+};
+
+describe('source-resolver', () => {
+  const tmpDir = os.tmpdir();
+  const testFilePath = path.join(tmpDir, 'test-resources.json');
+  const testDirPath = path.join(tmpDir, 'test-resource-dir');
+  const defaultFilePath = path.join(process.cwd(), 'resource-records.json');
+
+  const arrayData = [
+    { id: '1', kind: 'application', parentId: null, settings: {} },
+    { id: '2', kind: 'form', parentId: '1', settings: {} }
+  ];
+
+  const objectData = {
+    resourceRecords: [{ id: '1', kind: 'application', parentId: null, settings: {} }]
+  };
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe('resolveSource', () => {
+    it('should read array format JSON file', async () => {
+      mockedFs.pathExists.mockResolvedValue(true);
+      mockedFs.readJson.mockResolvedValue(arrayData);
+      mockedFs.stat.mockResolvedValue({ isDirectory: () => false } as fs.Stats);
+
+      const result = await resolveSource(testFilePath);
+      expect(result.resourceRecords).toHaveLength(2);
+      expect(result.format).toBe('array');
+      expect(result.filePath).toBe(testFilePath);
+    });
+
+    it('should read object format JSON file', async () => {
+      mockedFs.pathExists.mockResolvedValue(true);
+      mockedFs.readJson.mockResolvedValue(objectData);
+      mockedFs.stat.mockResolvedValue({ isDirectory: () => false } as fs.Stats);
+
+      const result = await resolveSource(testFilePath);
+      expect(result.resourceRecords).toHaveLength(1);
+      expect(result.format).toBe('object');
+      expect(result.filePath).toBe(testFilePath);
+    });
+
+    it('should read directory by appending default filename', async () => {
+      const dirFile = path.join(testDirPath, 'resource-records.json');
+      mockedFs.pathExists.mockResolvedValue(true);
+      mockedFs.readJson.mockResolvedValue(arrayData);
+      mockedFs.stat.mockResolvedValue({ isDirectory: () => true } as fs.Stats);
+
+      const result = await resolveSource(testDirPath);
+      expect(mockedFs.readJson).toHaveBeenCalledWith(dirFile);
+      expect(result.resourceRecords).toHaveLength(2);
+    });
+
+    it('should throw on missing default file', async () => {
+      mockedFs.pathExists.mockResolvedValue(false);
+
+      await expect(resolveSource(undefined)).rejects.toThrow('Default source file not found');
+    });
+
+    it('should throw on non-existent file', async () => {
+      mockedFs.pathExists.mockResolvedValue(false);
+      mockedFs.stat.mockRejectedValue(new Error('ENOENT'));
+      mockedFs.readJson.mockRejectedValue(new Error('File not found'));
+
+      await expect(resolveSource('/nonexistent/file.json')).rejects.toThrow('Source not found');
+    });
+
+    it('should throw on invalid JSON format', async () => {
+      mockedFs.pathExists.mockResolvedValue(true);
+      mockedFs.readJson.mockResolvedValue('invalid');
+      mockedFs.stat.mockResolvedValue({ isDirectory: () => false } as fs.Stats);
+
+      await expect(resolveSource(testFilePath)).rejects.toThrow('Invalid resource records format');
+    });
+
+    it('should throw on valid object without resourceRecords field', async () => {
+      mockedFs.pathExists.mockResolvedValue(true);
+      mockedFs.readJson.mockResolvedValue({ foo: 'bar' });
+      mockedFs.stat.mockResolvedValue({ isDirectory: () => false } as fs.Stats);
+
+      await expect(resolveSource(testFilePath)).rejects.toThrow('Invalid resource records format');
+    });
+  });
+
+  describe('isStdinSource', () => {
+    it('should return true for -', () => {
+      expect(isStdinSource('-')).toBe(true);
+    });
+
+    it('should return false for file paths', () => {
+      expect(isStdinSource('./data.json')).toBe(false);
+    });
+
+    it('should return false for undefined', () => {
+      expect(isStdinSource(undefined)).toBe(false);
+    });
+  });
+
+  describe('getSourceDescription', () => {
+    it('should return default path for undefined', () => {
+      expect(getSourceDescription(undefined)).toBe('./resource-records.json');
+    });
+
+    it('should return "stdin" for -', () => {
+      expect(getSourceDescription('-')).toBe('stdin');
+    });
+
+    it('should return the path itself', () => {
+      expect(getSourceDescription('./data.json')).toBe('./data.json');
+    });
+  });
+});

package/src/cli.ts

@@ -11,9 +11,25 @@ import {
   ZipAppDataLayout
 } from '@ldsg/utils';
 import { Command } from 'commander';
-import { DEFAULT_OUTPUT_PATH } from './constants';
+import { DEFAULT_OUTPUT_PATH, DEFAULT_SOURCE_FILE, DEFAULT_SOURCE_PATH } from './constants';
 import { getExtendAppDataParamsUsingNpmLdsgModule } from './utils/get-extend-app-data-params-using-npm-ldsg-module';
 import { getExtendAppDataParamsUsingWorkspaceLdsgModule } from './utils/get-extend-app-data-params-using-workspace-ldsg-module';
+import { resolveSource, isStdinSource, getSourceDescription } from './utils/source-resolver';
+import {
+  formatSuccess,
+  formatError,
+  formatJson,
+  formatPrettyList,
+  formatPrettyTree,
+  formatPrettyDiff
+} from './utils/formatter';
+import { createResource } from './commands/resource/create';
+import { updateResource } from './commands/resource/update';
+import { deleteResource } from './commands/resource/delete';
+import { listResources, getTree } from './commands/resource/list';
+import { getResource } from './commands/resource/get';
+import { convertResource } from './commands/resource/convert';
+import { diffResource } from './commands/resource/diff';
 
 const { version } = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
 
@@ -69,4 +85,296 @@ program
     });
   });
 
+const resource = program.command('resource').aliases(['r']).description('Manage resource records');
+
+resource
+  .command('list')
+  .description('List resource records by filter')
+  .option('--source <path>', `data source (default: ${DEFAULT_SOURCE_PATH})`)
+  .option('--kind <kind>', 'filter by resource kind')
+  .option('--parent-id <id>', 'filter by parent id')
+  .option('--root-id <id>', 'filter by root resource id')
+  .option('--pretty', 'human-readable output')
+  .action(async (options) => {
+    try {
+      const sourceDesc = getSourceDescription(options.source);
+      const sourceData = await resolveSource(options.source);
+      const { total, resources } = await listResources(sourceData.resourceRecords, {
+        kind: options.kind,
+        parentId: options.parentId,
+        rootId: options.rootId
+      });
+
+      if (options.pretty) {
+        console.log(
+          formatPrettyList(
+            resources.map((r) => ({
+              id: r.id,
+              kind: r.kind,
+              parentId: r.parentId,
+              title: (r.settings as Record<string, unknown>)?.title as string | undefined
+            }))
+          )
+        );
+      } else {
+        console.log(formatJson(formatSuccess({ source: sourceDesc, total, resources })));
+      }
+    } catch (error) {
+      console.error(formatJson(formatError('LIST_ERROR', (error as Error).message)));
+      process.exit(1);
+    }
+  });
+
+resource
+  .command('get <id>')
+  .description('Get a resource record by id')
+  .option('--source <path>', `data source (default: ${DEFAULT_SOURCE_PATH})`)
+  .option('--children', 'include direct children')
+  .option('--tree', 'include full subtree')
+  .option('--pretty', 'human-readable output')
+  .action(async (id, options) => {
+    try {
+      const sourceDesc = getSourceDescription(options.source);
+      const sourceData = await resolveSource(options.source);
+      const record = await getResource(sourceData.resourceRecords, id, {
+        children: options.children,
+        tree: options.tree
+      });
+
+      if (!record) {
+        console.error(formatJson(formatError('NOT_FOUND', `Resource with id "${id}" not found`)));
+        process.exit(1);
+      }
+
+      if (options.pretty) {
+        console.log(formatJson(record));
+      } else {
+        console.log(formatJson(formatSuccess({ source: sourceDesc, record })));
+      }
+    } catch (error) {
+      console.error(formatJson(formatError('GET_ERROR', (error as Error).message)));
+      process.exit(1);
+    }
+  });
+
+resource
+  .command('tree [root-id]')
+  .description('Display resource tree')
+  .option('--source <path>', `data source (default: ${DEFAULT_SOURCE_PATH})`)
+  .option('--show-kind', 'show resource kind prefix')
+  .option('--pretty', 'human-readable output')
+  .action(async (rootId, options) => {
+    try {
+      const sourceDesc = getSourceDescription(options.source);
+      const sourceData = await resolveSource(options.source);
+      const result = await getTree(sourceData.resourceRecords, rootId, options.showKind);
+
+      if (options.pretty) {
+        console.log(formatPrettyTree(result.tree as never, options.showKind ?? false));
+      } else {
+        console.log(formatJson(formatSuccess({ source: sourceDesc, ...result })));
+      }
+    } catch (error) {
+      console.error(formatJson(formatError('TREE_ERROR', (error as Error).message)));
+      process.exit(1);
+    }
+  });
+
+resource
+  .command('create')
+  .description('Create a new resource record')
+  .option('--source <path>', `data source (default: ${DEFAULT_SOURCE_PATH})`)
+  .option('--kind <kind>', 'resource kind')
+  .option('--parent-id <id>', 'parent resource id')
+  .option('--settings <json>', 'resource settings as JSON string')
+  .option('--from-file <path>', 'read full resource record from JSON file')
+  .option('--from-stdin', 'read full resource record from stdin')
+  .option('--dry-run', 'preview without writing')
+  .action(async (options) => {
+    try {
+      if (isStdinSource(options.source)) {
+        console.error(
+          formatJson(formatError('STDIN_NOT_WRITABLE', 'stdin source does not support write operations'))
+        );
+        process.exit(1);
+      }
+
+      const sourceData = await resolveSource(options.source);
+
+      let fromFileRecord: Record<string, unknown> | undefined;
+
+      if (options.fromFile) {
+        const fs = await import('fs-extra');
+        fromFileRecord = await fs.readJson(options.fromFile);
+      } else if (options.fromStdin) {
+        const chunks: Buffer[] = [];
+        process.stdin.setEncoding('utf-8');
+        for await (const chunk of process.stdin) {
+          chunks.push(Buffer.from(chunk));
+        }
+        const raw = Buffer.concat(chunks).toString('utf-8');
+        fromFileRecord = JSON.parse(raw);
+      }
+
+      let settings: Record<string, unknown> | undefined;
+      if (options.settings) {
+        settings = JSON.parse(options.settings);
+      }
+
+      const { record } = await createResource({
+        sourceData,
+        kind: options.kind,
+        parentId: options.parentId,
+        settings,
+        fromFileRecord: fromFileRecord as never,
+        dryRun: options.dryRun
+      });
+
+      console.log(formatJson(formatSuccess({ record, dryRun: options.dryRun ?? false })));
+    } catch (error) {
+      console.error(formatJson(formatError('CREATE_ERROR', (error as Error).message)));
+      process.exit(1);
+    }
+  });
+
+resource
+  .command('update <id>')
+  .description('Update a resource record')
+  .option('--source <path>', `data source (default: ${DEFAULT_SOURCE_PATH})`)
+  .option('--settings <json>', 'resource settings to merge (JSON string, required)')
+  .option('--dry-run', 'preview without writing')
+  .action(async (id, options) => {
+    try {
+      if (isStdinSource(options.source)) {
+        console.error(
+          formatJson(formatError('STDIN_NOT_WRITABLE', 'stdin source does not support write operations'))
+        );
+        process.exit(1);
+      }
+
+      const sourceData = await resolveSource(options.source);
+
+      if (!options.settings) {
+        console.error(formatJson(formatError('MISSING_SETTINGS', 'Required option: --settings <json>')));
+        process.exit(1);
+      }
+
+      const settings = JSON.parse(options.settings);
+      const { record } = await updateResource({
+        sourceData,
+        id,
+        settings,
+        dryRun: options.dryRun
+      });
+
+      console.log(formatJson(formatSuccess({ record, dryRun: options.dryRun ?? false })));
+    } catch (error) {
+      console.error(formatJson(formatError('UPDATE_ERROR', (error as Error).message)));
+      process.exit(1);
+    }
+  });
+
+resource
+  .command('delete <id>')
+  .description('Delete a resource record and its children')
+  .option('--source <path>', `data source (default: ${DEFAULT_SOURCE_PATH})`)
+  .option('--dry-run', 'preview deletion scope without writing')
+  .action(async (id, options) => {
+    try {
+      if (isStdinSource(options.source)) {
+        console.error(
+          formatJson(formatError('STDIN_NOT_WRITABLE', 'stdin source does not support write operations'))
+        );
+        process.exit(1);
+      }
+
+      const sourceData = await resolveSource(options.source);
+      const { removed } = await deleteResource({
+        sourceData,
+        id,
+        dryRun: options.dryRun
+      });
+
+      console.log(
+        formatJson(
+          formatSuccess({
+            dryRun: options.dryRun ?? false,
+            removedCount: removed.length,
+            removed: removed.map((r) => ({ id: r.id, kind: r.kind }))
+          })
+        )
+      );
+    } catch (error) {
+      console.error(formatJson(formatError('DELETE_ERROR', (error as Error).message)));
+      process.exit(1);
+    }
+  });
+
+resource
+  .command('convert')
+  .description('Convert resource records between aPaaS and Runtime formats')
+  .option('--from <format>', 'source format (apaas or runtime)')
+  .option('--to <format>', 'target format (apaas or runtime)')
+  .option('--input <path>', 'input file path')
+  .option('--output <path>', 'output file path (omit for stdout)')
+  .action(async (options) => {
+    try {
+      if (!options.from || !options.to || !options.input) {
+        console.error(formatJson(formatError('MISSING_ARGS', 'Required options: --from, --to, --input')));
+        process.exit(1);
+      }
+
+      const result = await convertResource({
+        from: options.from,
+        to: options.to,
+        input: options.input,
+        output: options.output
+      });
+
+      if (result.outputPath) {
+        console.log(formatJson(formatSuccess({ outputPath: result.outputPath })));
+      } else {
+        console.log(formatJson(formatSuccess({ data: result.data })));
+      }
+    } catch (error) {
+      console.error(formatJson(formatError('CONVERT_ERROR', (error as Error).message)));
+      process.exit(1);
+    }
+  });
+
+resource
+  .command('diff <id>')
+  .description('Diff a resource between two sources')
+  .option('--source-a <path>', 'first source file (required)')
+  .option('--source-b <path>', 'second source file (required)')
+  .option('--pretty', 'human-readable output')
+  .action(async (id, options) => {
+    try {
+      if (!options.sourceA || !options.sourceB) {
+        console.error(formatJson(formatError('MISSING_ARGS', 'Required options: --source-a, --source-b')));
+        process.exit(1);
+      }
+
+      const sourceDataA = await resolveSource(options.sourceA);
+      const sourceDataB = await resolveSource(options.sourceB);
+
+      const result = await diffResource({
+        sourceA: getSourceDescription(options.sourceA),
+        sourceB: getSourceDescription(options.sourceB),
+        id,
+        recordsA: sourceDataA.resourceRecords,
+        recordsB: sourceDataB.resourceRecords
+      });
+
+      if (options.pretty) {
+        console.log(formatPrettyDiff(result));
+      } else {
+        console.log(formatJson(formatSuccess(result)));
+      }
+    } catch (error) {
+      console.error(formatJson(formatError('DIFF_ERROR', (error as Error).message)));
+      process.exit(1);
+    }
+  });
+
 program.parse(process.argv);

package/src/commands/resource/convert.ts

@@ -0,0 +1,52 @@
+import fs from 'fs-extra';
+import { convertApaasResourceRecordsToResourceRecords } from '@ldsg/apaas-to-runtime';
+import { ResourceRecords } from '@ldsg/types';
+
+export interface ConvertOptions {
+  from: string;
+  to: string;
+  input: string;
+  output?: string;
+}
+
+export async function convertResource(
+  options: ConvertOptions
+): Promise<{ outputPath?: string; data: ResourceRecords }> {
+  const { from, to, input, output } = options;
+
+  if (from === 'runtime' && to === 'apaas') {
+    throw new Error('Runtime → aPaaS conversion is not supported yet');
+  }
+
+  if (from !== 'apaas' || to !== 'runtime') {
+    throw new Error(`Unsupported conversion: ${from} → ${to}`);
+  }
+
+  if (!(await fs.pathExists(input))) {
+    throw new Error(`Input file not found: ${input}`);
+  }
+
+  const rawData = await fs.readJson(input);
+  let resourceRecords: ResourceRecords;
+
+  if (Array.isArray(rawData)) {
+    resourceRecords = rawData as ResourceRecords;
+  } else if (rawData && typeof rawData === 'object' && Array.isArray(rawData.resourceRecords)) {
+    resourceRecords = rawData.resourceRecords as ResourceRecords;
+  } else {
+    throw new Error('Invalid input format: expected an array or { resourceRecords: [] }');
+  }
+
+  const { targetResourceRecords } = convertApaasResourceRecordsToResourceRecords({
+    resourceRecords
+  });
+
+  if (output) {
+    const isArrayInput = Array.isArray(rawData);
+    const outputData = isArrayInput ? targetResourceRecords : { resourceRecords: targetResourceRecords };
+    await fs.writeJson(output, outputData, { spaces: 2 });
+    return { outputPath: output, data: targetResourceRecords };
+  }
+
+  return { data: targetResourceRecords };
+}

package/src/commands/resource/create.ts

@@ -0,0 +1,49 @@
+import { ResourceRecord } from '@ldsg/types';
+import { SourceData } from '../../types/resource-record';
+import { appendRecord, generateId } from '../../utils/json-file-mutator';
+
+export interface CreateOptions {
+  sourceData: SourceData;
+  id?: string;
+  kind?: string;
+  parentId?: string;
+  settings?: Record<string, unknown>;
+  fromFileRecord?: Partial<ResourceRecord>;
+  dryRun?: boolean;
+}
+
+export async function createResource(options: CreateOptions): Promise<{ record: ResourceRecord }> {
+  const { sourceData, dryRun } = options;
+
+  let record: ResourceRecord;
+
+  if (options.fromFileRecord) {
+    const partial = options.fromFileRecord;
+    if (!partial.kind) {
+      throw new Error('Missing required field: kind');
+    }
+    record = {
+      id: partial.id || generateId(),
+      kind: partial.kind,
+      parentId: partial.parentId ?? sourceData.resourceRecords[0]?.parentId ?? null,
+      settings: (partial.settings || {}) as Record<string, unknown>
+    };
+  } else {
+    if (!options.kind) {
+      throw new Error('Missing required option: --kind');
+    }
+    if (options.parentId === undefined) {
+      throw new Error('Missing required option: --parent-id');
+    }
+
+    record = {
+      id: options.id || generateId(),
+      kind: options.kind,
+      parentId: options.parentId ?? null,
+      settings: options.settings || {}
+    };
+  }
+
+  const result = await appendRecord(sourceData, record, dryRun);
+  return { record: result.record };
+}

package/src/commands/resource/delete.ts

@@ -0,0 +1,15 @@
+import { ResourceRecord } from '@ldsg/types';
+import { SourceData } from '../../types/resource-record';
+import { removeRecord } from '../../utils/json-file-mutator';
+
+export interface DeleteOptions {
+  sourceData: SourceData;
+  id: string;
+  dryRun?: boolean;
+}
+
+export async function deleteResource(options: DeleteOptions): Promise<{ removed: ResourceRecord[] }> {
+  const { sourceData, id, dryRun } = options;
+  const result = await removeRecord(sourceData, id, dryRun);
+  return { removed: result.removed };
+}

package/src/commands/resource/diff.ts

@@ -0,0 +1,104 @@
+import { ResourceRecords } from '@ldsg/types';
+import { DiffResult } from '../../types/resource-record';
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+interface DiffEntry {
+  path: string;
+  from?: unknown;
+  to?: unknown;
+  value?: unknown;
+}
+
+function deepDiff(
+  objA: Record<string, unknown>,
+  objB: Record<string, unknown>,
+  basePath = ''
+): {
+  changed: DiffEntry[];
+  added: DiffEntry[];
+  removed: DiffEntry[];
+} {
+  const changed: DiffEntry[] = [];
+  const added: DiffEntry[] = [];
+  const removed: DiffEntry[] = [];
+
+  const allKeys = new Set([...Object.keys(objA), ...Object.keys(objB)]);
+
+  for (const key of allKeys) {
+    const path = basePath ? `${basePath}.${key}` : key;
+    const valA = objA[key];
+    const valB = objB[key];
+
+    if (key in objA && !(key in objB)) {
+      removed.push({ path, from: valA });
+    } else if (!(key in objA) && key in objB) {
+      added.push({ path, value: valB });
+    } else if (isObject(valA) && isObject(valB)) {
+      const nested = deepDiff(valA, valB, path);
+      changed.push(...nested.changed);
+      added.push(...nested.added);
+      removed.push(...nested.removed);
+    } else if (valA !== valB) {
+      changed.push({ path, from: valA, to: valB });
+    }
+  }
+
+  return { changed, added, removed };
+}
+
+export interface DiffOptions {
+  sourceA: string;
+  sourceB: string;
+  id: string;
+  recordsA: ResourceRecords;
+  recordsB: ResourceRecords;
+}
+
+export async function diffResource(options: DiffOptions): Promise<DiffResult> {
+  const { sourceA, sourceB, id, recordsA, recordsB } = options;
+
+  const recordA = recordsA.find((r) => r.id === id) || null;
+  const recordB = recordsB.find((r) => r.id === id) || null;
+
+  const result: DiffResult = {
+    id,
+    kind: (recordA || recordB)?.kind || '',
+    sourceA,
+    sourceB,
+    changed: [],
+    added: [],
+    removed: [],
+    sideA: recordA,
+    sideB: recordB
+  };
+
+  if (!recordA || !recordB) {
+    return result;
+  }
+
+  if (recordA.kind !== recordB.kind) {
+    result.changed.push({
+      path: 'kind',
+      from: recordA.kind,
+      to: recordB.kind
+    });
+  }
+
+  if (recordA.parentId !== recordB.parentId) {
+    result.changed.push({
+      path: 'parentId',
+      from: recordA.parentId || null,
+      to: recordB.parentId || null
+    });
+  }
+
+  const settingsDiff = deepDiff(recordA.settings || {}, recordB.settings || {});
+  result.changed.push(...settingsDiff.changed);
+  result.added.push(...settingsDiff.added);
+  result.removed.push(...settingsDiff.removed);
+
+  return result;
+}

package/src/commands/resource/get.ts

@@ -0,0 +1,5 @@
+import { ResourceRecords } from '@ldsg/types';
+import { getResource } from './list';
+
+export { getResource };
+export type GetOptions = { children?: boolean; tree?: boolean };