@izara_project/izara-core-generate-service-code 1.0.68 → 1.0.70

package/src/output/validateArtifacts.js

@@ -6,24 +6,32 @@ export function normalizeArtifacts(artifacts) {
   }
 
   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 });
-  }));
+  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) {
@@ -36,17 +44,19 @@ export function normalizeArtifactPaths(paths) {
   }
 
   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;
-  }));
+  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) {
+function _normalizeArtifactPath(path) {
   if (typeof path !== 'string' || path.trim() === '') {
     throw new TypeError('Artifact.path must be a non-empty relative path');
   }

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,100 @@ 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 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'
-  }]));
+  const outputPath = await mkdtemp(
+    join(tmpdir(), 'generate-service-code-v2-hooks-')
+  );
+  const sourcePath = join(outputPath, 'app/generated/source/example.js');
+  await mkdir(dirname(sourcePath), { recursive: true });
+  await writeFile(sourcePath, '//(<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'),
+    await readFile(sourcePath, '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,33 +181,37 @@ 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');
   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' }
-    ])),
+    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

@@ -17,7 +17,7 @@ const OWN_TOPIC_FLOWS = [
 ];
 after(() =>
   Promise.all(
-    [...roots].map(root => rm(root, { recursive: true, force: true }))
+    [...roots].map((root) => rm(root, { recursive: true, force: true }))
   )
 );
 

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,61 +57,139 @@ 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 });
-  await writeFile(
-    hookPath,
-    '  #<#CreateCompleteHdrSqsFunctionSetting#>\n  memorySize: 512\n  #<#/CreateCompleteHdrSqsFunctionSetting#>\n'
+  const yamlPath = join(
+    rootPath,
+    'app/sls_yaml/generatedCode/source/flow-objects.yml'
   );
 
   await generateCrudApplicationArtifacts(rootPath, { serviceTag: 'orders' });
+
+  const hookCode =
+    '  #<#CreateCompleteHdrSqsFunctionSetting#>\n  memorySize: 512\n  #<#/CreateCompleteHdrSqsFunctionSetting#>\n';
+  let yaml = await readFile(yamlPath, 'utf8');
+  const withHook = yaml.replace(
+    /  #<#CreateCompleteHdrSqsFunctionSetting#>[\s\S]*?#<#\/CreateCompleteHdrSqsFunctionSetting#>/,
+    hookCode.trim()
+  );
+  assert.notEqual(yaml, withHook, 'hook placeholder must exist in generated YAML');
+  await writeFile(yamlPath, withHook);
+
   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#>/);
+  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');
+  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'
+  await assert.rejects(
+    generateCrudApplicationArtifacts(rootPath, { serviceTag: 'orders' }),
+    /not a file/
   );
+  assert.equal(await readFile(yamlPath, 'utf8'), yaml);
 });
 
 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 });