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

package/src/generateResources/IntTest/generateTests/tests/tests.js

@@ -22,7 +22,7 @@ const __dirname = path.dirname(__filename);
 
 const templatePath = path.join(__dirname, './templateTests.ejs');
 
-import libs from '../../libs/libs.js';
+import libs from '../../libs/IntTestGenerateLib.js';
 const {
   createTestFunctionName,
   getHandlerFromEventTag,
@@ -31,7 +31,11 @@ const {
   setInvokeTest
 } = libs;
 
-import { HANDLER, GENERATE_SEED_DATA_TYPE, SEED_DATA_TAG } from '../../consts.js';
+import {
+  HANDLER,
+  GENERATE_SEED_DATA_TYPE,
+  SEED_DATA_TAG
+} from '../../consts.js';
 
 async function data(_izContext, allIntTestConfig, srcPath, serviceTag) {
   let createSourceData = [];
@@ -139,7 +143,7 @@ async function data(_izContext, allIntTestConfig, srcPath, serviceTag) {
             // baseIntTest.stage[currentStageIdx].invokes = invokeTest.invokeEventTags;
             stages[currentStageIdx].invokes = invokeTest.invokeEventTags;
 
-            const invokeStagesCloned = invokeTest.invokeStages.map(stage =>
+            const invokeStagesCloned = invokeTest.invokeStages.map((stage) =>
               structuredClone(stage)
             );
 

package/src/generateResources/IntTest/libs/{libs.js → IntTestGenerateLib.js}

@@ -1,7 +1,10 @@
-import { getObjectSchema, consts as coreConsts } from '@izara_project/izara-core-library-service-schemas';
+import {
+  getObjectSchema,
+  consts as coreConsts
+} from '@izara_project/izara-core-library-service-schemas';
 const { getDataFromPath } = getObjectSchema;
 const { HANDLER } = coreConsts;
-import yaml from 'yaml';
+import yamlLib from 'yaml';
 import fs from 'fs';
 import path from 'path';
 
@@ -22,13 +25,13 @@ function directoryPath(dirPath, result = []) {
       directoryPath(fullPath, result); // ✅ ใช้ result เดียวกัน
     } else if (stat.isFile()) {
       if (
-        !fullPath.includes("shared-resource.yml") &&
-        !fullPath.includes("core-function.yml")
+        !fullPath.includes('shared-resource.yml') &&
+        !fullPath.includes('core-function.yml')
       ) {
-        if (fullPath.endsWith(".yml")) {
+        if (fullPath.endsWith('.yml')) {
           result.push(fullPath);
         } else {
-          console.log("Skipped File:", fullPath);
+          console.log('Skipped File:', fullPath);
         }
       }
     }
@@ -37,19 +40,19 @@ function directoryPath(dirPath, result = []) {
   let functionComponent = {};
 
   for (let ymlFilesPath of result) {
-    const fileContent = fs.readFileSync(ymlFilesPath, "utf8");
-    const parsedYaml = yaml.parse(fileContent);
+    const fileContent = fs.readFileSync(ymlFilesPath, 'utf8');
+    const parsedYaml = yamlLib.parse(fileContent);
 
     for (const component of Object.values(parsedYaml)) {
       if (component.handler && component.name) {
         const clearName = component.name.replace(
-          "${self:custom.iz_resourcePrefix}",
-          ""
+          '${self:custom.iz_resourcePrefix}',
+          ''
         );
-        const clearMain = component.handler.replace(/\.main$/, "");
+        const clearMain = component.handler.replace(/\.main$/, '');
 
         Object.assign(functionComponent, {
-          [clearName]: clearMain,
+          [clearName]: clearMain
         });
       }
     }
@@ -347,16 +350,19 @@ function setNoInvokeTest(
 // setTests
 
 function createEventCaseByHandler(handler, messageAttributes = {}) {
-  return {
-    [HANDLER.hdrApi]: {},
-    [HANDLER.hdrDsq]: { DirectSqs: true },
-    [HANDLER.hdrInv]: {},
-    [HANDLER.hdrSqs]: {
-      ...(messageAttributes && Object.keys(messageAttributes).length > 0
-        ? { messageAttributes: setEventMessageAttributes(messageAttributes) }
-        : {})
+  if (handler === HANDLER.hdrDsq) {
+    return { DirectSqs: true };
+  }
+  if (handler === HANDLER.hdrSqs) {
+    if (messageAttributes && Object.keys(messageAttributes).length > 0) {
+      return { messageAttributes: setEventMessageAttributes(messageAttributes) };
     }
-  }[handler];
+    return {};
+  }
+  if (handler === HANDLER.hdrApi || handler === HANDLER.hdrInv) {
+    return {};
+  }
+  return null;
 }
 
 function getHandlerFromEventTag(testTag) {
@@ -395,11 +401,16 @@ function createResourceName(eventTag) {
 async function getIntTestConfig(_izContext, intTestPath, rootPath) {
   // ponytail: find first existing integration test libs folder or fall back to standard path
   const targetLibsPath = rootPath.includes('generateIntegrationTest')
-    ? path.join(rootPath.split('generateIntegrationTest')[0], 'generateIntegrationTest', 'libs')
+    ? path.join(
+        rootPath.split('generateIntegrationTest')[0],
+        'generateIntegrationTest',
+        'libs'
+      )
     : [
         path.join(rootPath, 'app/src/generateIntegrationTest/libs'),
         path.join(rootPath, 'src/generateIntegrationTest/libs')
-      ].find(fs.existsSync) || path.join(rootPath, 'src/generateIntegrationTest/libs');
+      ].find(fs.existsSync) ||
+      path.join(rootPath, 'src/generateIntegrationTest/libs');
 
   return await getObjectSchema.getDataFromPath(
     _izContext,

package/src/generateResources/IntTest/upload/uploadIntTest.js

@@ -22,15 +22,17 @@ import Logger from '@izara_project/izara-core-library-logger';
 const DEFAULT_BUCKET = 'integrationtest-config-us-east-2';
 const _izContext = { Logger };
 
-function getAllFiles(dirPath, filePaths = []) {
-  if (!fs.existsSync(dirPath)) return filePaths;
+function _getAllFiles(dirPath, filePaths = []) {
+  if (!fs.existsSync(dirPath)) {
+    return filePaths;
+  }
 
   for (const file of fs.readdirSync(dirPath)) {
     const fullPath = path.join(dirPath, file);
     const stat = fs.statSync(fullPath);
 
     if (stat.isDirectory()) {
-      getAllFiles(fullPath, filePaths);
+      _getAllFiles(fullPath, filePaths);
       continue;
     }
 
@@ -42,15 +44,18 @@ function getAllFiles(dirPath, filePaths = []) {
 
 async function bucketPathForUpload(folderPath, settings = {}) {
   const dataToUploads = [];
-  const files = getAllFiles(folderPath);
+  const files = _getAllFiles(folderPath);
 
   for (const filePath of files) {
     const fileContent = fs.readFileSync(filePath);
-    // ponytail: use indexOf to find first occurrence of serviceTag so nested test case folders containing the serviceTag name do not get cut off.
-    const index = settings.serviceTag ? filePath.indexOf(settings.serviceTag) : -1;
-    const relativePath = index !== -1
-      ? filePath.substring(index)
-      : path.basename(filePath);
+    let index = -1;
+    if (settings.serviceTag) {
+      index = filePath.indexOf(settings.serviceTag);
+    }
+    let relativePath = path.basename(filePath);
+    if (index !== -1) {
+      relativePath = filePath.substring(index);
+    }
     const s3Key = path
       .join('test_config', settings.s3Prefix || '', relativePath)
       .split(path.sep)
@@ -64,18 +69,27 @@ async function bucketPathForUpload(folderPath, settings = {}) {
 
 async function uploadToS3(folderPath, settings = {}) {
   const uploads = await bucketPathForUpload(folderPath, settings);
-  const bucket = settings.bucket || DEFAULT_BUCKET;
-
-  await Promise.all(uploads.map(({ key, fileContent }) => (
-    s3.putObjectS3(_izContext, {
-      Bucket: bucket,
-      Key: key,
-      Body: fileContent,
-      ContentType: 'application/json'
+  let bucket = DEFAULT_BUCKET;
+  if (settings.bucket) {
+    bucket = settings.bucket;
+  }
+
+  await Promise.all(
+    uploads.map(async ({ key, fileContent }) => {
+      await s3.putObjectS3(_izContext, {
+        Bucket: bucket,
+        Key: key,
+        Body: fileContent,
+        ContentType: 'application/json'
+      });
     })
-  )));
+  );
 
-  return uploads.map(({ key }) => key);
+  const keys = [];
+  for (const { key } of uploads) {
+    keys.push(key);
+  }
+  return keys;
 }
 
 export { DEFAULT_BUCKET, bucketPathForUpload, uploadToS3 };

package/src/intTestGeneratorShared.js

@@ -1,32 +1,37 @@
 import { existsSync, readdirSync, readFileSync, rmSync } from 'fs';
 import { join } from 'path';
-import yaml from 'yaml';
+import yamlLib from 'yaml';
 
 function getServiceTag(rootPath) {
   const configPath = join(rootPath, 'config', 'serverless.config.yml');
-  const config = yaml.parse(readFileSync(configPath, 'utf8'));
+  const config = yamlLib.parse(readFileSync(configPath, 'utf8'));
   return config?.main_config?.iz_serviceTag;
 }
 
 function getIntTestOutputPath(outputPath, projectRootPath = outputPath) {
-  return existsSync(join(projectRootPath, 'app'))
-    ? join(outputPath, 'app', 'src', 'generateIntegrationTest')
-    : join(outputPath, 'src', 'generateIntegrationTest');
+  if (existsSync(join(projectRootPath, 'app'))) {
+    return join(outputPath, 'app', 'src', 'generateIntegrationTest');
+  }
+  return join(outputPath, 'src', 'generateIntegrationTest');
 }
 
-function clearSavePath(savePath, preserveFileNames = []) {
-  if (!savePath || !existsSync(savePath)) return;
+function _clearSavePath(savePath, preserveFileNames = []) {
+  if (!savePath || !existsSync(savePath)) {
+    return;
+  }
 
   const preserved = new Set(preserveFileNames);
   for (const entry of readdirSync(savePath)) {
-    if (preserved.has(entry)) continue;
+    if (preserved.has(entry)) {
+      continue;
+    }
     rmSync(join(savePath, entry), { recursive: true, force: true });
   }
 }
 
 async function runTemplateItems(items, { writeSource, errorPrefix }) {
   const normalizedItems = (items || []).filter(
-    item => !(Array.isArray(item) && item.length === 0)
+    (item) => !(Array.isArray(item) && item.length === 0)
   );
   if (!normalizedItems.length) {
     return;
@@ -55,7 +60,7 @@ async function runTemplateItems(items, { writeSource, errorPrefix }) {
     const savePath = item.setting?.savePath;
     const cleanSavePathEnabled = item.setting?.cleanSavePath !== false;
     if (savePath && cleanSavePathEnabled && !clearedPaths.has(savePath)) {
-      clearSavePath(savePath, item.setting?.preserveFileNames || []);
+      _clearSavePath(savePath, item.setting?.preserveFileNames || []);
       clearedPaths.add(savePath);
     }
 

package/src/output/commitArtifacts.js

@@ -1,8 +1,22 @@
 import { constants } from 'node:fs';
-import { copyFile, lstat, mkdir, mkdtemp, readFile, realpath, rename, rm, unlink, writeFile } from 'node:fs/promises';
+import {
+  copyFile,
+  lstat,
+  mkdir,
+  mkdtemp,
+  readFile,
+  realpath,
+  rename,
+  rm,
+  unlink,
+  writeFile
+} from 'node:fs/promises';
 import { dirname, join, relative, resolve, sep } from 'node:path';
 
-import { normalizeArtifactPaths, validateArtifacts } from './validateArtifacts.js';
+import {
+  normalizeArtifactPaths,
+  validateArtifacts
+} from './validateArtifacts.js';
 import { mergeHooks } from './mergeHooks.js';
 
 const MANAGED_ARTIFACTS_PATH = '.generate-service-code-v2-managed.json';
@@ -10,36 +24,51 @@ const STAGING_PREFIX = '.generate-service-code-v2-stage-';
 
 export async function commitArtifacts(plan) {
   if (!plan?.project?.outputPath || !Array.isArray(plan.artifacts)) {
-    throw new TypeError('GenerationPlan must include project.outputPath and artifacts');
+    throw new TypeError(
+      'GenerationPlan must include project.outputPath and artifacts'
+    );
   }
 
   const outputRoot = resolve(plan.project.outputPath);
   const artifacts = validateArtifacts(plan.artifacts);
   await mkdir(outputRoot, { recursive: true });
   const physicalOutputRoot = await realpath(outputRoot);
-  const manifestPath = await resolveSafeTarget(physicalOutputRoot, MANAGED_ARTIFACTS_PATH);
-  const managedArtifacts = await loadManagedArtifacts(manifestPath);
-  const managedScopes = normalizeManagedScopes(plan);
-  const stalePaths = staleManagedPaths(managedScopes, managedArtifacts, artifacts);
+  const manifestPath = await _resolveSafeTarget(
+    physicalOutputRoot,
+    MANAGED_ARTIFACTS_PATH
+  );
+  const managedArtifacts = await _loadManagedArtifacts(manifestPath);
+  const managedScopes = _normalizeManagedScopes(plan);
+  const stalePaths = _staleManagedPaths(
+    managedScopes,
+    managedArtifacts,
+    artifacts
+  );
   const mergedArtifacts = await mergeHooks(physicalOutputRoot, artifacts);
   const stagedRoot = await mkdtemp(join(physicalOutputRoot, STAGING_PREFIX));
 
   try {
-    const changes = await stageChanges({
+    let manifestContent;
+    if (managedScopes) {
+      manifestContent = _managedManifestContent(
+        managedScopes,
+        managedArtifacts,
+        mergedArtifacts
+      );
+    }
+    const changes = await _stageChanges({
       outputRoot: physicalOutputRoot,
       stagedRoot,
       artifacts: mergedArtifacts,
       stalePaths,
       manifestPath,
-      manifestContent: managedScopes
-        ? managedManifestContent(managedScopes, managedArtifacts, mergedArtifacts)
-        : undefined
+      manifestContent
     });
-    const snapshots = await snapshotChanges(changes, stagedRoot);
+    const snapshots = await _snapshotChanges(changes, stagedRoot);
     try {
-      await applyChanges(changes);
+      await _applyChanges(changes);
     } catch (error) {
-      await rollbackChanges(changes, snapshots);
+      await _rollbackChanges(changes, snapshots);
       throw error;
     }
   } finally {
@@ -49,21 +78,23 @@ export async function commitArtifacts(plan) {
   return mergedArtifacts.map(({ path }) => ({ path }));
 }
 
-function normalizeManagedScopes(plan) {
-  if (plan.managedScopes !== undefined) {
+function _normalizeManagedScopes(plan) {
+  if (plan.managedScopes !== undefined && plan.managedScopes !== null) {
     return plan.managedScopes;
   }
-  if (plan.managedScope === undefined) {
-    return undefined;
+  if (plan.managedScope === undefined || plan.managedScope === null) {
+    return null;
   }
-  return { [plan.managedScope]: normalizeArtifactPaths(plan.managedPaths ?? []) };
+  return {
+    [plan.managedScope]: normalizeArtifactPaths(plan.managedPaths ?? [])
+  };
 }
 
-function staleManagedPaths(managedScopes, managedArtifacts, artifacts) {
+function _staleManagedPaths(managedScopes, managedArtifacts, artifacts) {
   if (!managedScopes) {
     return [];
   }
-  const emittedPaths = new Set(artifacts.map(artifact => artifact.path));
+  const emittedPaths = new Set(artifacts.map((artifact) => artifact.path));
   const stalePaths = new Set();
   for (const [scope, declaredPaths] of Object.entries(managedScopes)) {
     if (!Object.hasOwn(managedArtifacts, scope)) {
@@ -78,35 +109,58 @@ function staleManagedPaths(managedScopes, managedArtifacts, artifacts) {
   return [...stalePaths];
 }
 
-function managedManifestContent(managedScopes, managedArtifacts, artifacts) {
-  const emittedPaths = new Set(artifacts.map(artifact => artifact.path));
+function _managedManifestContent(managedScopes, managedArtifacts, artifacts) {
+  const emittedPaths = new Set(artifacts.map((artifact) => artifact.path));
   const nextManifest = { ...managedArtifacts };
   for (const [scope, paths] of Object.entries(managedScopes)) {
-    nextManifest[scope] = paths.filter(path => emittedPaths.has(path));
+    nextManifest[scope] = paths.filter((path) => emittedPaths.has(path));
   }
   return `${JSON.stringify(nextManifest, null, 2)}\n`;
 }
 
-async function stageChanges({ outputRoot, stagedRoot, artifacts, stalePaths, manifestPath, manifestContent }) {
+async function _stageChanges({
+  outputRoot,
+  stagedRoot,
+  artifacts,
+  stalePaths,
+  manifestPath,
+  manifestContent
+}) {
   const changes = [];
   for (const artifact of artifacts) {
-    const targetPath = await resolveSafeTarget(outputRoot, artifact.path);
-    const stagedPath = await resolveSafeTarget(stagedRoot, artifact.path, { createDirectories: true });
-    await writeFile(stagedPath, artifact.content, { encoding: 'utf8', flag: constants.O_WRONLY | constants.O_CREAT | constants.O_TRUNC | constants.O_NOFOLLOW });
+    const targetPath = await _resolveSafeTarget(outputRoot, artifact.path);
+    const stagedPath = await _resolveSafeTarget(stagedRoot, artifact.path, {
+      createDirectories: true
+    });
+    await writeFile(stagedPath, artifact.content, {
+      encoding: 'utf8',
+      flag:
+        constants.O_WRONLY |
+        constants.O_CREAT |
+        constants.O_TRUNC |
+        constants.O_NOFOLLOW
+    });
     changes.push({ targetPath, stagedPath });
   }
   for (const path of stalePaths) {
-    changes.push({ targetPath: await resolveSafeTarget(outputRoot, path), delete: true });
+    changes.push({
+      targetPath: await _resolveSafeTarget(outputRoot, path),
+      delete: true
+    });
   }
   if (manifestContent !== undefined) {
-    const stagedPath = await resolveSafeTarget(stagedRoot, MANAGED_ARTIFACTS_PATH, { createDirectories: true });
+    const stagedPath = await _resolveSafeTarget(
+      stagedRoot,
+      MANAGED_ARTIFACTS_PATH,
+      { createDirectories: true }
+    );
     await writeFile(stagedPath, manifestContent, 'utf8');
     changes.push({ targetPath: manifestPath, stagedPath });
   }
   return changes;
 }
 
-async function snapshotChanges(changes, stagedRoot) {
+async function _snapshotChanges(changes, stagedRoot) {
   const snapshots = new Map();
   for (const [index, change] of changes.entries()) {
     try {
@@ -128,10 +182,10 @@ async function snapshotChanges(changes, stagedRoot) {
   return snapshots;
 }
 
-async function applyChanges(changes) {
+async function _applyChanges(changes) {
   for (const change of changes) {
     if (change.delete) {
-      await unlink(change.targetPath).catch(ignoreMissingFile);
+      await unlink(change.targetPath).catch(_ignoreMissingFile);
       continue;
     }
     await mkdir(dirname(change.targetPath), { recursive: true });
@@ -139,11 +193,11 @@ async function applyChanges(changes) {
   }
 }
 
-async function rollbackChanges(changes, snapshots) {
+async function _rollbackChanges(changes, snapshots) {
   for (const change of [...changes].reverse()) {
     const snapshot = snapshots.get(change.targetPath);
     if (!snapshot) {
-      await unlink(change.targetPath).catch(ignoreMissingFile);
+      await unlink(change.targetPath).catch(_ignoreMissingFile);
       continue;
     }
     await mkdir(dirname(change.targetPath), { recursive: true });
@@ -151,13 +205,13 @@ async function rollbackChanges(changes, snapshots) {
   }
 }
 
-function ignoreMissingFile(error) {
+function _ignoreMissingFile(error) {
   if (error.code !== 'ENOENT') {
     throw error;
   }
 }
 
-async function loadManagedArtifacts(manifestPath) {
+async function _loadManagedArtifacts(manifestPath) {
   try {
     const parsed = JSON.parse(await readFile(manifestPath, 'utf8'));
     if (!parsed || Array.isArray(parsed) || typeof parsed !== 'object') {
@@ -175,7 +229,11 @@ async function loadManagedArtifacts(manifestPath) {
   }
 }
 
-async function resolveSafeTarget(outputRoot, artifactPath, { createDirectories = false } = {}) {
+async function _resolveSafeTarget(
+  outputRoot,
+  artifactPath,
+  { createDirectories = false } = {}
+) {
   const targetPath = resolve(outputRoot, artifactPath);
   if (relative(outputRoot, targetPath).startsWith('..')) {
     throw new Error(`Artifact path escapes output root: ${artifactPath}`);
@@ -187,7 +245,9 @@ async function resolveSafeTarget(outputRoot, artifactPath, { createDirectories =
     try {
       const details = await lstat(currentPath);
       if (details.isSymbolicLink() || !details.isDirectory()) {
-        throw new Error(`Artifact path traverses a non-directory: ${artifactPath}`);
+        throw new Error(
+          `Artifact path traverses a non-directory: ${artifactPath}`
+        );
       }
     } catch (error) {
       if (error.code !== 'ENOENT') {

package/src/output/mergeHooks.js

@@ -2,10 +2,12 @@ import { lstat, readFile } from 'node:fs/promises';
 import { join, sep } from 'node:path';
 
 export async function mergeHooks(outputRoot, artifacts) {
-  return Promise.all(artifacts.map(async artifact => ({
-    ...artifact,
-    content: await mergeHook(outputRoot, artifact)
-  })));
+  return Promise.all(
+    artifacts.map(async (artifact) => ({
+      ...artifact,
+      content: await mergeHook(outputRoot, artifact)
+    }))
+  );
 }
 
 async function mergeHook(outputRoot, artifact) {
@@ -15,7 +17,12 @@ async function mergeHook(outputRoot, artifact) {
     return artifact.content;
   }
 
-  const hookPath = join(outputRoot, ...parts.slice(0, sourceIndex), 'hook', ...parts.slice(sourceIndex + 1));
+  const hookPath = join(
+    outputRoot,
+    ...parts.slice(0, sourceIndex),
+    'hook',
+    ...parts.slice(sourceIndex + 1)
+  );
   try {
     if (!(await lstat(hookPath)).isFile()) {
       return artifact.content;
@@ -33,22 +40,29 @@ async function mergeHook(outputRoot, artifact) {
   }
 
   const hookContent = await readFile(hookPath, 'utf8');
-  return artifact.content.replace(matchers.anyTag, (match, tagName) => (
-    hookContent.match(matchers.tagPattern(tagName))?.[0] ?? match
-  ));
+  return artifact.content.replace(
+    matchers.anyTag,
+    (match, tagName) =>
+      hookContent.match(matchers.tagPattern(tagName))?.[0] ?? match
+  );
 }
 
 function hookMatchers(filePath) {
   if (filePath.endsWith('.js')) {
     return {
       anyTag: /\/\/\(<(\w+)>\)([\s\S]*?)\/\/\(<\/\1>\)/gm,
-      tagPattern: name => new RegExp(`\\/\\/\\(<${name}>\\)([\\s\\S]*?)\\/\\/\\(<\\/${name}>\\)`, 'gm')
+      tagPattern: (name) =>
+        new RegExp(
+          `\\/\\/\\(<${name}>\\)([\\s\\S]*?)\\/\\/\\(<\\/${name}>\\)`,
+          'gm'
+        )
     };
   }
   if (filePath.endsWith('.yml') || filePath.endsWith('.yaml')) {
     return {
       anyTag: /#<#(\w+)#>([\s\S]*?)#<#\/\1#>/gm,
-      tagPattern: name => new RegExp(`#<#${name}#>([\\s\\S]*?)#<#\\/${name}#>`, 'gm')
+      tagPattern: (name) =>
+        new RegExp(`#<#${name}#>([\\s\\S]*?)#<#\\/${name}#>`, 'gm')
     };
   }
   return null;

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');
   }