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

package/src/plan/buildGenerationPlan.js

@@ -1,24 +1,33 @@
-import { normalizeArtifactPaths, validateArtifacts } from '../output/validateArtifacts.js';
+import {
+  normalizeArtifactPaths,
+  validateArtifacts
+} from '../output/validateArtifacts.js';
 
-export function buildGenerationPlan(project, artifacts = [], { managedPaths = [], managedScope, managedScopes } = {}) {
+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');
+    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)
+    managedScope: _normalizeManagedScope(managedScope),
+    managedScopes: _normalizeManagedScopes(managedScopes)
   });
 }
 
-function normalizeManagedScope(scope) {
-  if (scope === undefined) {
-    return undefined;
+function _normalizeManagedScope(scope) {
+  if (scope === undefined || scope === null) {
+    return null;
   }
   if (typeof scope !== 'string' || scope.trim() === '') {
     throw new TypeError('managedScope must be a non-empty string');
@@ -26,9 +35,9 @@ function normalizeManagedScope(scope) {
   return scope;
 }
 
-function normalizeManagedScopes(scopes) {
-  if (scopes === undefined) {
-    return undefined;
+function _normalizeManagedScopes(scopes) {
+  if (scopes === undefined || scopes === null) {
+    return null;
   }
   if (!scopes || Array.isArray(scopes) || typeof scopes !== 'object') {
     throw new TypeError('managedScopes must be an object of scope paths');
@@ -36,11 +45,13 @@ function normalizeManagedScopes(scopes) {
   const seenPaths = new Set();
   const normalized = {};
   for (const [scope, paths] of Object.entries(scopes)) {
-    const scopeName = normalizeManagedScope(scope);
+    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}`);
+        throw new Error(
+          `Artifact path belongs to multiple managed scopes: ${path}`
+        );
       }
       seenPaths.add(path);
     }

package/test/core.test.js

@@ -1,5 +1,12 @@
 import assert from 'node:assert/strict';
-import { mkdir, mkdtemp, readFile, readdir, symlink, writeFile } from 'node:fs/promises';
+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';
@@ -15,7 +22,9 @@ test('compiles a request and commits only declared relative artifacts', async ()
     { path: 'app/generated/example.js', content: 'export default 1;\n' }
   ]);
 
-  assert.deepEqual(await commitArtifacts(plan), [{ path: 'app/generated/example.js' }]);
+  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'
@@ -25,25 +34,35 @@ test('compiles a request and commits only declared relative artifacts', async ()
 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 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: '' }])),
+    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: '' }
-    ])),
+    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-'));
+  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 }), [
@@ -55,64 +74,104 @@ test('rejects a symlinked output directory', async () => {
 });
 
 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 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 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 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 }));
+  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 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');
+  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 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'
-  }]));
+  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');
+  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 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');
@@ -126,13 +185,17 @@ test('rejects an invalid rendered artifact before staging output', async () => {
   );
   assert.equal(await readFile(sourcePath, 'utf8'), 'existing source\n');
   assert.deepEqual(
-    (await readdir(outputPath)).filter(name => name.startsWith('.generate-service-code-v2-stage-')),
+    (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 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');
@@ -143,16 +206,20 @@ test('rejects a failed output transaction without partial files, hooks, or stagi
   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' }
-    ])),
+    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-')),
+    (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

@@ -15,27 +15,55 @@ const OWN_TOPIC_FLOWS = [
   'CreateUserRole',
   'DeleteUserFromRole'
 ];
-after(() => Promise.all([...roots].map(root => rm(root, { recursive: true, force: true }))));
+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'),
+    await readFile(join(rootPath, result.files[0].path), 'utf8'),
+    /CreateTargetRole/
+  );
+  assert.match(
+    await readFile(join(rootPath, result.files[1].path), 'utf8'),
+    /CreateTargetRoleHdrSqs/
+  );
+  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/
+    await readFile(
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowRbac/ListTargetRole/source/ListTargetRole_HdrApi.js'
+      ),
+      'utf8'
+    ),
+    /ListTargetRole/
+  );
+  const yaml = await readFile(
+    join(rootPath, 'app/sls_yaml/generatedCode/source/flow-rbac.yml'),
+    'utf8'
   );
-  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'),
+      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:`));
@@ -46,23 +74,44 @@ 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");
+  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')));
+  await assert.rejects(
+    readFile(
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowRbac/CreateTargetRole/source/CreateTargetRole_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-'));
+  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`
+    `export default { objectType: 'user', fieldNames: [], identifiers: [], addOnDataStructure: ${addOns} };\n`
   );
   return rootPath;
 }

package/test/crudApplicationArtifacts.test.js

@@ -5,26 +5,49 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import test, { after } from 'node:test';
 
+process.env.NODE_ENV = '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 }))));
+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' });
+  const result = await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
 
   assert.equal(result.files.length, 26);
-  assert.ok(result.files.every(file => !file.path.includes('/Process')));
+  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'),
+    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'),
+    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');
+  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/);
@@ -34,24 +57,68 @@ test('emits CRUD handlers and function YAML from schema data without reading gen
   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'),
+    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'),
+    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')));
+  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' });
+    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 });
+  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'
@@ -60,15 +127,27 @@ test('preserves function-setting hooks across CRUD regeneration', async () => {
   await generateCrudApplicationArtifacts(rootPath, { serviceTag: 'orders' });
   await generateCrudApplicationArtifacts(rootPath, { serviceTag: 'orders' });
 
-  const yamlPath = join(rootPath, 'app/sls_yaml/generatedCode/source/flow-objects.yml');
+  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#>/);
+  assert.match(
+    yaml,
+    /#<#CreateCompleteHdrSqsFunctionSetting#>\n  memorySize: 512\n  #<#\/CreateCompleteHdrSqsFunctionSetting#>/
+  );
 
-  const conflictPath = join(rootPath, 'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js');
+  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/);
+  await assert.rejects(
+    generateCrudApplicationArtifacts(rootPath, { serviceTag: 'orders' }),
+    /not a file/
+  );
   assert.equal(await readFile(yamlPath, 'utf8'), yaml);
   assert.equal(
     await readFile(hookPath, 'utf8'),
@@ -79,16 +158,42 @@ test('preserves function-setting hooks across CRUD regeneration', async () => {
 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");
+  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')));
+  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-'));
+  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 });