@izara_project/izara-core-generate-service-code 1.0.65 → 1.0.67

package/src/output/validateArtifacts.js

@@ -0,0 +1,62 @@
+import { isAbsolute, normalize } from 'node:path';
+
+export function normalizeArtifacts(artifacts) {
+  if (!Array.isArray(artifacts)) {
+    throw new TypeError('artifacts must be an array');
+  }
+
+  const paths = new Set();
+  return Object.freeze(artifacts.map(artifact => {
+    if (!artifact || typeof artifact.path !== 'string' || artifact.path.trim() === '') {
+      throw new TypeError('Artifact.path must be a non-empty relative path');
+    }
+    if (isAbsolute(artifact.path)) {
+      throw new TypeError(`Artifact.path must be relative: ${artifact.path}`);
+    }
+    if (typeof artifact.content !== 'string') {
+      throw new TypeError(`Artifact.content must be a string: ${artifact.path}`);
+    }
+
+    const path = normalizeArtifactPath(artifact.path);
+    if (paths.has(path)) {
+      throw new Error(`Duplicate artifact path: ${path}`);
+    }
+    paths.add(path);
+    return Object.freeze({ path, content: artifact.content });
+  }));
+}
+
+export function validateArtifacts(artifacts) {
+  return normalizeArtifacts(artifacts);
+}
+
+export function normalizeArtifactPaths(paths) {
+  if (!Array.isArray(paths)) {
+    throw new TypeError('managedPaths must be an array');
+  }
+
+  const seenPaths = new Set();
+  return Object.freeze(paths.map(path => {
+    const normalizedPath = normalizeArtifactPath(path);
+    if (seenPaths.has(normalizedPath)) {
+      throw new Error(`Duplicate artifact path: ${normalizedPath}`);
+    }
+    seenPaths.add(normalizedPath);
+    return normalizedPath;
+  }));
+}
+
+function normalizeArtifactPath(path) {
+  if (typeof path !== 'string' || path.trim() === '') {
+    throw new TypeError('Artifact.path must be a non-empty relative path');
+  }
+  if (isAbsolute(path)) {
+    throw new TypeError(`Artifact.path must be relative: ${path}`);
+  }
+
+  const normalizedPath = normalize(path);
+  if (normalizedPath === '..' || normalizedPath.startsWith('../')) {
+    throw new TypeError(`Artifact.path escapes output root: ${path}`);
+  }
+  return normalizedPath;
+}

package/src/plan/buildGenerationPlan.js

@@ -0,0 +1,50 @@
+import { normalizeArtifactPaths, validateArtifacts } from '../output/validateArtifacts.js';
+
+export function buildGenerationPlan(project, artifacts = [], { managedPaths = [], managedScope, managedScopes } = {}) {
+  if (!project?.rootPath || !project?.outputPath) {
+    throw new TypeError('ProjectModel must include rootPath and outputPath');
+  }
+  if (managedScope !== undefined && managedScopes !== undefined) {
+    throw new TypeError('GenerationPlan must use managedScope or managedScopes, not both');
+  }
+  return Object.freeze({
+    project,
+    artifacts: validateArtifacts(artifacts),
+    managedPaths: normalizeArtifactPaths(managedPaths),
+    managedScope: normalizeManagedScope(managedScope),
+    managedScopes: normalizeManagedScopes(managedScopes)
+  });
+}
+
+function normalizeManagedScope(scope) {
+  if (scope === undefined) {
+    return undefined;
+  }
+  if (typeof scope !== 'string' || scope.trim() === '') {
+    throw new TypeError('managedScope must be a non-empty string');
+  }
+  return scope;
+}
+
+function normalizeManagedScopes(scopes) {
+  if (scopes === undefined) {
+    return undefined;
+  }
+  if (!scopes || Array.isArray(scopes) || typeof scopes !== 'object') {
+    throw new TypeError('managedScopes must be an object of scope paths');
+  }
+  const seenPaths = new Set();
+  const normalized = {};
+  for (const [scope, paths] of Object.entries(scopes)) {
+    const scopeName = normalizeManagedScope(scope);
+    const normalizedPaths = normalizeArtifactPaths(paths);
+    for (const path of normalizedPaths) {
+      if (seenPaths.has(path)) {
+        throw new Error(`Artifact path belongs to multiple managed scopes: ${path}`);
+      }
+      seenPaths.add(path);
+    }
+    normalized[scopeName] = normalizedPaths;
+  }
+  return Object.freeze(normalized);
+}

package/test/core.test.js

@@ -0,0 +1,159 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, readdir, symlink, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import test from 'node:test';
+
+import { buildGenerationPlan } from '../src/plan/buildGenerationPlan.js';
+import { commitArtifacts } from '../src/output/commitArtifacts.js';
+import { compileProject } from '../src/compile/compileProject.js';
+
+test('compiles a request and commits only declared relative artifacts', async () => {
+  const outputPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-'));
+  const project = compileProject({ rootPath: outputPath });
+  const plan = buildGenerationPlan(project, [
+    { path: 'app/generated/example.js', content: 'export default 1;\n' }
+  ]);
+
+  assert.deepEqual(await commitArtifacts(plan), [{ path: 'app/generated/example.js' }]);
+  assert.equal(
+    await readFile(join(outputPath, 'app/generated/example.js'), 'utf8'),
+    'export default 1;\n'
+  );
+});
+
+test('rejects invalid generation inputs before writing files', async () => {
+  assert.throws(() => compileProject({}), /rootPath/);
+
+  const outputPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-invalid-'));
+  const project = compileProject({ rootPath: outputPath });
+  await assert.rejects(
+    Promise.resolve().then(() => buildGenerationPlan(project, [{ path: '../outside.js', content: '' }])),
+    /escapes output root/
+  );
+  await assert.rejects(
+    Promise.resolve().then(() => buildGenerationPlan(project, [
+      { path: 'same.js', content: '' },
+      { path: 'same.js', content: '' }
+    ])),
+    /Duplicate artifact path/
+  );
+  await assert.rejects(readFile(join(outputPath, 'same.js')));
+});
+
+test('rejects a symlinked output directory', async () => {
+  const outputPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-output-'));
+  const outsidePath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-outside-'));
+  await symlink(outsidePath, join(outputPath, 'linked'));
+
+  const plan = buildGenerationPlan(compileProject({ rootPath: outputPath }), [
+    { path: 'linked/escaped.js', content: 'export default 1;\n' }
+  ]);
+
+  await assert.rejects(commitArtifacts(plan), /non-directory/);
+  await assert.rejects(readFile(join(outsidePath, 'escaped.js')));
+});
+
+test('does not delete a legacy file before a managed scope has established ownership', async () => {
+  const outputPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-managed-scope-'));
+  const project = compileProject({ rootPath: outputPath });
+  await writeFile(join(outputPath, 'legacy.js'), 'legacy\n');
+
+  await commitArtifacts(buildGenerationPlan(project, [], {
+    managedPaths: ['legacy.js'],
+    managedScope: 'example-scope'
+  }));
+  assert.equal(await readFile(join(outputPath, 'legacy.js'), 'utf8'), 'legacy\n');
+
+  await commitArtifacts(buildGenerationPlan(project, [{ path: 'legacy.js', content: 'v2\n' }], {
+    managedPaths: ['legacy.js'],
+    managedScope: 'example-scope'
+  }));
+  await commitArtifacts(buildGenerationPlan(project, [], {
+    managedPaths: ['legacy.js'],
+    managedScope: 'example-scope'
+  }));
+  await assert.rejects(readFile(join(outputPath, 'legacy.js')));
+});
+
+test('commits and cleans multiple managed scopes in one transaction', async () => {
+  const outputPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-multi-scope-'));
+  const project = compileProject({ rootPath: outputPath });
+  const managedScopes = { schemas: ['schemas.js'], application: ['application.js'] };
+  await commitArtifacts(buildGenerationPlan(project, [
+    { path: 'schemas.js', content: 'schema\n' },
+    { path: 'application.js', content: 'application\n' }
+  ], { managedScopes }));
+
+  await commitArtifacts(buildGenerationPlan(project, [
+    { path: 'application.js', content: 'application next\n' }
+  ], { managedScopes }));
+
+  await assert.rejects(readFile(join(outputPath, 'schemas.js')));
+  assert.equal(await readFile(join(outputPath, 'application.js'), 'utf8'), 'application next\n');
+});
+
+test('merges preserved hook blocks into staged source without changing the hook', async () => {
+  const outputPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-hooks-'));
+  const hookPath = join(outputPath, 'app/generated/hook/example.js');
+  await mkdir(dirname(hookPath), { recursive: true });
+  await writeFile(hookPath, '//(<hookCode>)\ncustom();\n//(</hookCode>)\n');
+
+  await commitArtifacts(buildGenerationPlan(compileProject({ rootPath: outputPath }), [{
+    path: 'app/generated/source/example.js',
+    content: '//(<hookCode>)\ndefault();\n//(</hookCode>)\n'
+  }]));
+
+  assert.equal(
+    await readFile(join(outputPath, 'app/generated/source/example.js'), 'utf8'),
+    '//(<hookCode>)\ncustom();\n//(</hookCode>)\n'
+  );
+  assert.equal(await readFile(hookPath, 'utf8'), '//(<hookCode>)\ncustom();\n//(</hookCode>)\n');
+});
+
+test('rejects an invalid rendered artifact before staging output', async () => {
+  const outputPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-invalid-render-'));
+  const sourcePath = join(outputPath, 'app/generated/source/example.js');
+  await mkdir(dirname(sourcePath), { recursive: true });
+  await writeFile(sourcePath, 'existing source\n');
+
+  await assert.rejects(
+    commitArtifacts({
+      project: compileProject({ rootPath: outputPath }),
+      artifacts: [{ path: 'app/generated/source/example.js', content: null }]
+    }),
+    /content must be a string/
+  );
+  assert.equal(await readFile(sourcePath, 'utf8'), 'existing source\n');
+  assert.deepEqual(
+    (await readdir(outputPath)).filter(name => name.startsWith('.generate-service-code-v2-stage-')),
+    []
+  );
+});
+
+test('rejects a failed output transaction without partial files, hooks, or staging residue', async () => {
+  const outputPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-transaction-'));
+  const project = compileProject({ rootPath: outputPath });
+  const sourcePath = join(outputPath, 'app/generated/source/first.js');
+  const hookPath = join(outputPath, 'app/generated/hook/first.js');
+  await mkdir(dirname(sourcePath), { recursive: true });
+  await mkdir(dirname(hookPath), { recursive: true });
+  await writeFile(sourcePath, 'old source\n');
+  await writeFile(hookPath, 'custom hook\n');
+  await mkdir(join(outputPath, 'app/generated/source/second.js'));
+
+  await assert.rejects(
+    commitArtifacts(buildGenerationPlan(project, [
+      { path: 'app/generated/source/first.js', content: 'new source\n' },
+      { path: 'app/generated/source/second.js', content: 'never committed\n' }
+    ])),
+    /not a file/
+  );
+  assert.equal(await readFile(sourcePath, 'utf8'), 'old source\n');
+  assert.equal(await readFile(hookPath, 'utf8'), 'custom hook\n');
+  assert.deepEqual(
+    (await readdir(outputPath)).filter(name => name.startsWith('.generate-service-code-v2-stage-')),
+    []
+  );
+  assert.equal((await readdir(outputPath)).includes('.bak'), false);
+});

package/test/createTargetRoleHandler.test.js

@@ -0,0 +1,68 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test, { after } from 'node:test';
+
+import { generateCreateTargetRoleHandler } from '../src/emit/rbac/generateCreateTargetRoleHandler.js';
+
+const roots = new Set();
+const OWN_TOPIC_FLOWS = [
+  'CreateTargetRole',
+  'CreateRolePermissions',
+  'DeleteRolePermissions',
+  'DeleteTargetRole',
+  'CreateUserRole',
+  'DeleteUserFromRole'
+];
+after(() => Promise.all([...roots].map(root => rm(root, { recursive: true, force: true }))));
+
+test('generates RBAC own-topic WebSocket entries alongside their SQS handlers', async () => {
+  const rootPath = await createProject(true);
+  const result = await generateCreateTargetRoleHandler(rootPath);
+
+  assert.equal(result.files.length, 36);
+  assert.match(await readFile(join(rootPath, result.files[0].path), 'utf8'), /ProcessCreateTargetRole/);
+  assert.match(await readFile(join(rootPath, result.files[1].path), 'utf8'), /ProcessCreateTargetRoleHdrSqs/);
+  assert.match(
+    await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-rbac.yml'), 'utf8'),
+    /FlowRbacRole/
+  );
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowRbac/ListTargetRole/source/ProcessListTargetRole_HdrApi.js'), 'utf8'),
+    /ProcessListTargetRole/
+  );
+  const yaml = await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-rbac.yml'), 'utf8');
+  for (const flowTag of OWN_TOPIC_FLOWS) {
+    assert.match(
+      await readFile(join(rootPath, `app/src/generatedCode/FlowRbac/${flowTag}/source/${flowTag}_HdrWbs.js`), 'utf8'),
+      new RegExp(`import ${flowTag}`)
+    );
+    assert.match(yaml, new RegExp(`${flowTag}HdrWbs:\\n[\\s\\S]*websocket:`));
+  }
+});
+
+test('removes CreateTargetRole handler when RBAC is removed', async () => {
+  const rootPath = await createProject(true);
+  const objectPath = join(rootPath, 'app/src/schemas/ObjectSchemas/User.js');
+  await generateCreateTargetRoleHandler(rootPath);
+  await writeFile(objectPath, "export default { objectType: 'user', addOnDataStructure: [] };\n");
+
+  assert.deepEqual((await generateCreateTargetRoleHandler(rootPath)).files, []);
+  await assert.rejects(readFile(join(rootPath, 'app/src/generatedCode/FlowRbac/CreateTargetRole/source/ProcessCreateTargetRole_Main.js')));
+  await assert.rejects(readFile(join(rootPath, 'app/src/generatedCode/FlowRbac/CreateTargetRole/source/CreateTargetRole_HdrWbs.js')));
+  await assert.rejects(readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-rbac.yml')));
+});
+
+async function createProject(hasRbac) {
+  const rootPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-rbac-handler-'));
+  roots.add(rootPath);
+  const directory = join(rootPath, 'app/src/schemas/ObjectSchemas');
+  const addOns = hasRbac ? "[{ type: 'rbac' }]" : '[]';
+  await mkdir(directory, { recursive: true });
+  await writeFile(
+    join(directory, 'User.js'),
+    `export default { objectType: 'user', addOnDataStructure: ${addOns} };\n`
+  );
+  return rootPath;
+}

package/test/crudApplicationArtifacts.test.js

@@ -0,0 +1,107 @@
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test, { after } from 'node:test';
+
+import { generateCrudApplicationArtifacts } from '../src/emit/crud/generateCrudApplicationArtifacts.js';
+
+const roots = new Set();
+after(() => Promise.all([...roots].map(root => rm(root, { recursive: true, force: true }))));
+
+test('emits CRUD handlers and function YAML from schema data without reading generated output', async () => {
+  const rootPath = await createProject(true);
+  const result = await generateCrudApplicationArtifacts(rootPath, { serviceTag: 'orders' });
+
+  assert.equal(result.files.length, 26);
+  assert.ok(result.files.every(file => !file.path.includes('/Process')));
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowObjects/Get/source/Get_Main.js'), 'utf8'),
+    /dataFromGraphV2/
+  );
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js'), 'utf8'),
+    /beforeLogical_order/
+  );
+  const yaml = await readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-objects.yml'), 'utf8');
+  assert.match(yaml, /CreateHdrWbs:/);
+  assert.ok(yaml.indexOf('CreateHdrWbs:') < yaml.indexOf('CreateHdrSqs:'));
+  assert.doesNotMatch(yaml, /handler: .*\/Process/);
+  assert.match(yaml, /path: \/orders\/order\/get/);
+  assert.match(yaml, /GetHdrInv:/);
+  assert.match(yaml, /CreateCompleteHdrSqs:/);
+  assert.match(yaml, /#<#CreateCompleteHdrSqsFunctionSetting#>/);
+  assert.match(yaml, /filterPatterns:[\s\S]*CreateCompleteHdrSqs/);
+  assert.match(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowObjects/Create/source/CreateComplete_Main.js'), 'utf8'),
+    /checkAllAwaitingStepsFinishedWithReturnParams/
+  );
+  assert.doesNotMatch(
+    await readFile(join(rootPath, 'app/src/generatedCode/FlowObjects/Create/source/Create_WbsMain.js'), 'utf8'),
+    /from '@izara_project\/izara-core-generate-service-code'/
+  );
+  await assert.rejects(readFile(join(rootPath, 'app/src/generatedCode/FlowObjects/Create/source/ProcessCreate_Main.js')));
+  for (const action of ['Create', 'Update', 'Delete']) {
+    execFileSync(process.execPath, ['--check', join(rootPath, `app/src/generatedCode/FlowObjects/${action}/source/${action}Complete_Main.js`)], { stdio: 'inherit' });
+    execFileSync(process.execPath, ['--check', join(rootPath, `app/src/generatedCode/FlowObjects/${action}/source/${action}Complete_HdrSqs.js`)], { stdio: 'inherit' });
+  }
+});
+
+test('preserves function-setting hooks across CRUD regeneration', async () => {
+  const rootPath = await createProject(true);
+  const hookPath = join(rootPath, 'app/sls_yaml/generatedCode/hook/flow-objects.yml');
+  await mkdir(join(rootPath, 'app/sls_yaml/generatedCode/hook'), { recursive: true });
+  await writeFile(
+    hookPath,
+    '  #<#CreateCompleteHdrSqsFunctionSetting#>\n  memorySize: 512\n  #<#/CreateCompleteHdrSqsFunctionSetting#>\n'
+  );
+
+  await generateCrudApplicationArtifacts(rootPath, { serviceTag: 'orders' });
+  await generateCrudApplicationArtifacts(rootPath, { serviceTag: 'orders' });
+
+  const yamlPath = join(rootPath, 'app/sls_yaml/generatedCode/source/flow-objects.yml');
+  const yaml = await readFile(yamlPath, 'utf8');
+  assert.match(yaml, /#<#CreateCompleteHdrSqsFunctionSetting#>\n  memorySize: 512\n  #<#\/CreateCompleteHdrSqsFunctionSetting#>/);
+
+  const conflictPath = join(rootPath, 'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js');
+  await rm(conflictPath);
+  await mkdir(conflictPath);
+
+  await assert.rejects(generateCrudApplicationArtifacts(rootPath, { serviceTag: 'orders' }), /not a file/);
+  assert.equal(await readFile(yamlPath, 'utf8'), yaml);
+  assert.equal(
+    await readFile(hookPath, 'utf8'),
+    '  #<#CreateCompleteHdrSqsFunctionSetting#>\n  memorySize: 512\n  #<#/CreateCompleteHdrSqsFunctionSetting#>\n'
+  );
+});
+
+test('removes managed CRUD artifacts when no applicable object remains', async () => {
+  const rootPath = await createProject(true);
+  await generateCrudApplicationArtifacts(rootPath, { serviceTag: 'orders' });
+  await writeFile(join(rootPath, 'app/src/schemas/ObjectSchemas/Order.js'), "export default { objectType: 'order' };\n");
+
+  assert.deepEqual((await generateCrudApplicationArtifacts(rootPath)).files, []);
+  await assert.rejects(readFile(join(rootPath, 'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js')));
+  await assert.rejects(readFile(join(rootPath, 'app/src/generatedCode/FlowObjects/Create/source/CreateComplete_Main.js')));
+  await assert.rejects(readFile(join(rootPath, 'app/sls_yaml/generatedCode/source/flow-objects.yml')));
+});
+
+async function createProject(withCrudObject) {
+  const rootPath = await mkdtemp(join(tmpdir(), 'generate-service-code-v2-crud-application-'));
+  roots.add(rootPath);
+  const schemaRoot = join(rootPath, 'app/src/schemas');
+  await mkdir(join(schemaRoot, 'ObjectSchemas'), { recursive: true });
+  await mkdir(join(schemaRoot, 'FlowSchemas'), { recursive: true });
+  await writeFile(
+    join(schemaRoot, 'ObjectSchemas/Order.js'),
+    withCrudObject
+      ? "export default { objectType: 'order', generatedBy: 'userGenerated' };\n"
+      : "export default { objectType: 'order' };\n"
+  );
+  await writeFile(
+    join(schemaRoot, 'FlowSchemas/OrderBeforeLogical.js'),
+    "export default { flowTag: 'orderHook', event: ['ownTopic'], generatedCodeConfig: { generatedCodeTag: 'create', codeHookTag: 'beforeLogical', invocationType: 'ownTopic', objType: { objectType: 'order' } } };\n"
+  );
+  return rootPath;
+}