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

package/src/emit/system/emitSystemFindDataArtifacts.js

@@ -0,0 +1,266 @@
+import ejsLib from 'ejs';
+import { readFile } from 'node:fs/promises';
+
+const SHARED_TEMPLATE_URL = new URL('../shared/templates/', import.meta.url);
+const FIND_DATA_SOURCE = 'app/src/generatedCode/FindData/source';
+const FIND_DATA_HANDLER_ROOT = 'src/generatedCode/FindData/source';
+const PROCESS_LOGICAL_SOURCE = 'app/src/generatedCode/ProcessLogical/source';
+const PROCESS_LOGICAL_HANDLER_ROOT = 'src/generatedCode/ProcessLogical/source';
+const YAML_PATH = 'app/sls_yaml/generatedCode/source/flow-system.yml';
+
+const STORAGE_TYPES = { dynamoDB: 'dynamoDB', graph: 'graph' };
+
+export async function emitSystemFindDataArtifacts(objects) {
+  return _emitSystemArtifacts(objects);
+}
+
+export function findDataManagedPaths() {
+  return [
+    `${FIND_DATA_SOURCE}/FindData_Main.js`,
+    `${FIND_DATA_SOURCE}/FindData_HdrSqs.js`,
+    `${PROCESS_LOGICAL_SOURCE}/ProcessLogical_Main.js`,
+    `${PROCESS_LOGICAL_SOURCE}/ProcessLogical_HdrSqs.js`,
+    `${PROCESS_LOGICAL_SOURCE}/PaginateProcessLogical_Main.js`,
+    `${PROCESS_LOGICAL_SOURCE}/PaginateProcessLogical_HdrDsq.js`,
+    `${PROCESS_LOGICAL_SOURCE}/PaginateProcessLogical_HdrSqs.js`,
+    YAML_PATH
+  ];
+}
+
+function _hasStorageObjects(objects) {
+  if (!Array.isArray(objects) || objects.length === 0) {
+    return false;
+  }
+  return objects.some(
+    (object) =>
+      object.storageResources &&
+      Object.keys(object.storageResources).length > 0
+  );
+}
+
+async function _emitSystemArtifacts(objects) {
+  if (!_hasStorageObjects(objects)) {
+    return [];
+  }
+
+  const hasFindDataEntries = buildFindDataEntries(objects).length > 0;
+
+  const artifacts = [];
+
+  if (hasFindDataEntries) {
+    const findDataMain = await render('FindData_Main.ejs', {
+      datas: buildFindDataEntries(objects)
+    });
+    artifacts.push(
+      { path: `${FIND_DATA_SOURCE}/FindData_Main.js`, content: findDataMain },
+      {
+        path: `${FIND_DATA_SOURCE}/FindData_HdrSqs.js`,
+        content: await render('FindData_HdrSqs.ejs', {})
+      }
+    );
+  }
+
+  artifacts.push(
+    {
+      path: `${PROCESS_LOGICAL_SOURCE}/ProcessLogical_Main.js`,
+      content: await render('ProcessLogical_Main.ejs', {})
+    },
+    {
+      path: `${PROCESS_LOGICAL_SOURCE}/ProcessLogical_HdrSqs.js`,
+      content: await render('ProcessLogical_HdrSqs.ejs', {})
+    },
+    {
+      path: `${PROCESS_LOGICAL_SOURCE}/PaginateProcessLogical_Main.js`,
+      content: await render('PaginateProcessLogical_Main.ejs', {})
+    },
+    {
+      path: `${PROCESS_LOGICAL_SOURCE}/PaginateProcessLogical_HdrDsq.js`,
+      content: await render('PaginateProcessLogical_HdrDsq.ejs', {})
+    },
+    {
+      path: `${PROCESS_LOGICAL_SOURCE}/PaginateProcessLogical_HdrSqs.js`,
+      content: await render('PaginateProcessLogical_HdrSqs.ejs', {})
+    },
+    {
+      path: YAML_PATH,
+      content: renderSystemYaml()
+    }
+  );
+
+  return artifacts;
+}
+
+function renderSystemYaml() {
+  const findDataYaml = renderFindDataYaml();
+  const processLogicalYaml = renderProcessLogicalYaml();
+  const processLogicalPaginateDsqYaml = renderProcessLogicalPaginateDsqYaml();
+  const processLogicalPaginateSqsYaml = renderProcessLogicalPaginateSqsYaml();
+  return [
+    findDataYaml,
+    processLogicalYaml,
+    processLogicalPaginateDsqYaml,
+    processLogicalPaginateSqsYaml
+  ].join('\n\n');
+}
+
+function renderFindDataYaml() {
+  return _renderSqsYaml({
+    functionName: 'FindData',
+    handlerRoot: FIND_DATA_HANDLER_ROOT,
+    roleName: 'ProcFindDataRole'
+  });
+}
+
+function renderProcessLogicalYaml() {
+  return _renderSqsYaml({
+    functionName: 'ProcessLogical',
+    handlerRoot: PROCESS_LOGICAL_HANDLER_ROOT,
+    roleName: 'ProcFindDataRole'
+  });
+}
+
+function renderProcessLogicalPaginateDsqYaml() {
+  return _renderSqsYaml({
+    functionName: 'PaginateProcessLogical',
+    handlerType: 'HdrDsq',
+    handlerRoot: PROCESS_LOGICAL_HANDLER_ROOT,
+    roleName: 'ProcFindDataRole'
+  });
+}
+
+function renderProcessLogicalPaginateSqsYaml() {
+  return _renderSqsYaml({
+    functionName: 'PaginateProcessLogical',
+    handlerRoot: PROCESS_LOGICAL_HANDLER_ROOT,
+    roleName: 'ProcFindDataRole'
+  });
+}
+
+function _renderSqsYaml({
+  functionName,
+  handlerType = 'HdrSqs',
+  handlerRoot,
+  roleName
+}) {
+  const upperHandlerType = handlerType;
+  const handlerPath = `${handlerRoot}/${functionName}_${upperHandlerType}.main`;
+  const name = `${functionName}${upperHandlerType}`;
+  return `${name}:
+  handler: ${handlerPath}
+  name: \${self:custom.iz_resourcePrefix}${name}
+  role: ${roleName}
+  #<#${name}FunctionSetting#>
+  #<#/${name}FunctionSetting#>
+  events:
+    - sqs:
+        arn: arn:aws:sqs:\${self:custom.iz_region}:\${self:custom.iz_accountId}:\${self:custom.iz_resourcePrefix}${name}
+        batchSize: 10`;
+}
+
+function buildFindDataEntries(objects) {
+  return objects
+    .filter(
+      (object) =>
+        object.storageResources &&
+        Object.keys(object.storageResources).length > 0
+    )
+    .map((object) => {
+      const objectType = object.objectType;
+      const storageResources = object.storageResources;
+      const fieldNames = object.fieldNames || {};
+      const identifiers = object.identifiers || [];
+      const identifierNames = new Set(
+        identifiers.map((id) => id.fieldName).filter(Boolean)
+      );
+
+      const fieldEntries = [];
+
+      for (const [field, schemas] of Object.entries(fieldNames)) {
+        if (schemas.type !== 'string' && schemas.type !== 'number') {
+          continue;
+        }
+
+        const storageResourceTags = schemas.storageResourceTags;
+        if (
+          !Array.isArray(storageResourceTags) ||
+          storageResourceTags.length === 0
+        ) {
+          continue;
+        }
+
+        const collectStorageDetail = {};
+        const getInIdentifiers = identifierNames.has(field);
+
+        for (const storageTag of storageResourceTags) {
+          const storageDetail = storageResources[storageTag];
+          if (!storageDetail) {
+            continue;
+          }
+
+          if (storageDetail.storageType === STORAGE_TYPES.graph) {
+            if (!collectStorageDetail[STORAGE_TYPES.graph]) {
+              collectStorageDetail[STORAGE_TYPES.graph] = {
+                graphServerTag: storageDetail.graphServerTag,
+                getInIdentifiers
+              };
+            }
+          } else if (storageDetail.storageType === STORAGE_TYPES.dynamoDB) {
+            if (!collectStorageDetail[STORAGE_TYPES.dynamoDB]) {
+              collectStorageDetail[STORAGE_TYPES.dynamoDB] = {
+                tableName: storageDetail.tableName
+              };
+            }
+          }
+        }
+
+        if (
+          collectStorageDetail[STORAGE_TYPES.graph] &&
+          collectStorageDetail[STORAGE_TYPES.dynamoDB]
+        ) {
+          delete collectStorageDetail[STORAGE_TYPES.graph];
+        }
+
+        if (Object.keys(collectStorageDetail).length > 0) {
+          fieldEntries.push({ [field]: collectStorageDetail });
+        }
+      }
+
+      if (Array.isArray(object.addOnDataStructure)) {
+        for (const versionedData of object.addOnDataStructure) {
+          if (versionedData.type === 'versionedData') {
+            const versionedStorageTag = versionedData.storageResourceTag;
+            const versionedFieldNames = versionedData.fieldNames || {};
+            const storageDetail = storageResources[versionedStorageTag];
+
+            if (
+              storageDetail &&
+              storageDetail.storageType === STORAGE_TYPES.graph
+            ) {
+              const versionedStorageDetail = {
+                [STORAGE_TYPES.graph]: {
+                  graphServerTag: storageDetail.graphServerTag,
+                  versionedDataLabel: versionedData.versionedDataLabel
+                }
+              };
+
+              for (const [key, value] of Object.entries(versionedFieldNames)) {
+                if (value.type === 'string' || value.type === 'number') {
+                  fieldEntries.push({ [key]: versionedStorageDetail });
+                }
+              }
+            }
+          }
+        }
+      }
+
+      return { objectType, fieldNames: fieldEntries };
+    })
+    .filter((entry) => entry.fieldNames.length > 0);
+}
+
+async function render(templateName, data) {
+  return ejsLib.render(
+    await readFile(new URL(templateName, SHARED_TEMPLATE_URL), 'utf8'),
+    data
+  );
+}

package/src/emit/system/templates/WebSocketComplete_HdrSqs.ejs

@@ -9,21 +9,37 @@ const perRecordsValidatorSchema = {};
 export const main = middleware.wrap(async (event, context, callback) => {
   try {
     const recordPromises = [];
-    await Promise.all(event.Records.map(async record => {
-      record._izContext.logger.debug('record ReceiveMsgOutHdrSqs', record);
-      await recordHandlerSharedLib.validateRecord(record, 'WebSocketCompleteHdrSqs', perRecordsValidatorSchema);
-      recordPromises.push(recordHandlerSharedLib.recordHandler(
-        record,
-        WebSocketComplete,
-        'WebSocketCompleteHdrSqs',
-        [record.body.TopicArn, record.body.Message, callingFlowSharedLib.addCallingFlowToPassOnProperties(record.body.Message)]
-      ));
-    }));
+    await Promise.all(
+      event.Records.map(async (record) => {
+        record._izContext.logger.debug('record ReceiveMsgOutHdrSqs', record);
+        await recordHandlerSharedLib.validateRecord(
+          record,
+          'WebSocketCompleteHdrSqs',
+          perRecordsValidatorSchema
+        );
+        recordPromises.push(
+          recordHandlerSharedLib.recordHandler(
+            record,
+            WebSocketComplete,
+            'WebSocketCompleteHdrSqs',
+            [
+              record.body.TopicArn,
+              record.body.Message,
+              callingFlowSharedLib.addCallingFlowToPassOnProperties(
+                record.body.Message
+              )
+            ]
+          )
+        );
+      })
+    );
     try {
       await Promise.all(recordPromises);
       return event.Records;
     } catch {
-      Logger.debug('Promise.all(recordPromises) in handler threw error (at least one record did no resolve)');
+      Logger.debug(
+        'Promise.all(recordPromises) in handler threw error (at least one record did no resolve)'
+      );
     }
   } catch (error) {
     Logger.error('Unhandled Error, WebSocketComplete_HdrSqs: ', error);

package/src/emit/system/templates/WebSocketComplete_Main.ejs

@@ -1,44 +1,89 @@
 import { NoRetryError } from '@izara_project/izara-core-library-core';
 import { consts } from '@izara_project/izara-middleware';
-import { getObjectSchema, utils } from '@izara_project/izara-core-library-service-schemas';
+import {
+  getObjectSchema,
+  utils
+} from '@izara_project/izara-core-library-service-schemas';
 import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
 import { webSocket } from '@izara_project/izara-core-library-external-request';
 
 const { createFlowTypeConcat } = utils;
 const { postToConnection } = webSocket;
 
-export default async function WebSocketComplete(_izContext, topicArn, requestParams, callingFlowConfig = {}) {
+export default async function WebSocketComplete(
+  _izContext,
+  topicArn,
+  requestParams,
+  callingFlowConfig = {}
+) {
   try {
     _izContext.logger.debug('WebSocketComplete _izContext', _izContext);
     _izContext.logger.debug('WebSocketComplete requestParams', requestParams);
-    _izContext.logger.debug('WebSocketComplete callingFlowConfig', callingFlowConfig);
-    const correlationId = _izContext.correlationIds.get(consts.X_CORRELATION_ID);
-    if (!topicArn) throw new NoRetryError('not have TopicArn for get FlowSchemas');
+    _izContext.logger.debug(
+      'WebSocketComplete callingFlowConfig',
+      callingFlowConfig
+    );
+    const correlationId = _izContext.correlationIds.get(
+      consts.X_CORRELATION_ID
+    );
+    if (!topicArn)
+      throw new NoRetryError('not have TopicArn for get FlowSchemas');
     const topicName = topicArn.split(':')[5].split('_');
     let flowTag = topicName[2];
-    let flowSchema = await getObjectSchema.getFlowSchemaS3WithCache(_izContext, { flowTag, serviceTag: topicName[0] });
+    let flowSchema = await getObjectSchema.getFlowSchemaS3WithCache(
+      _izContext,
+      { flowTag, serviceTag: topicName[0] }
+    );
     if (!flowSchema) {
-      if (!requestParams?.hasOwnProperty('flowTag')) throw new NoRetryError('Could not find flowSchema from topicArn or requestParams.flowTag');
+      if (!requestParams?.hasOwnProperty('flowTag'))
+        throw new NoRetryError(
+          'Could not find flowSchema from topicArn or requestParams.flowTag'
+        );
       flowTag = requestParams.flowTag;
-      flowSchema = await getObjectSchema.getFlowSchemaS3WithCache(_izContext, { flowTag, serviceTag: process.env.iz_serviceTag });
+      flowSchema = await getObjectSchema.getFlowSchemaS3WithCache(_izContext, {
+        flowTag,
+        serviceTag: process.env.iz_serviceTag
+      });
     }
     //(<createIdentifiersFlow>)
     let identifiers;
     //(</createIdentifiersFlow>)
     let taskKey;
-    if (flowSchema.statusType === 'statusField' || flowSchema.statusType === 'storedCache' || flowSchema.statusType === 'triggerCache') {
-      taskKey = createFlowTypeConcat(_izContext, { flowTag, serviceTag: topicName[0] }) + identifiers;
+    if (
+      flowSchema.statusType === 'statusField' ||
+      flowSchema.statusType === 'storedCache' ||
+      flowSchema.statusType === 'triggerCache'
+    ) {
+      taskKey =
+        createFlowTypeConcat(_izContext, {
+          flowTag,
+          serviceTag: topicName[0]
+        }) + identifiers;
     } else if (flowSchema.statusType === 'none') {
-      taskKey = createFlowTypeConcat(_izContext, { flowTag, serviceTag: topicName[0] }) + correlationId;
+      taskKey =
+        createFlowTypeConcat(_izContext, {
+          flowTag,
+          serviceTag: topicName[0]
+        }) + correlationId;
     }
     if (!taskKey) return;
-    const tasks = await dynamodbSharedLib.query(_izContext, await dynamodbSharedLib.tableName(_izContext, 'WebSocketTask'), { taskKey });
-    await Promise.all((tasks.Items ?? []).map(async task => {
-      //(<beforePostMessage>)
-      //(</beforePostMessage>)
-      await postToConnection({ message: requestParams }, task.connectionId);
-      await dynamodbSharedLib.deleteItem(_izContext, await dynamodbSharedLib.tableName(_izContext, 'WebSocketTask'), { taskKey: task.taskKey, connectionId: task.connectionId });
-    }));
+    const tasks = await dynamodbSharedLib.query(
+      _izContext,
+      await dynamodbSharedLib.tableName(_izContext, 'WebSocketTask'),
+      { taskKey }
+    );
+    await Promise.all(
+      (tasks.Items ?? []).map(async (task) => {
+        //(<beforePostMessage>)
+        //(</beforePostMessage>)
+        await postToConnection({ message: requestParams }, task.connectionId);
+        await dynamodbSharedLib.deleteItem(
+          _izContext,
+          await dynamodbSharedLib.tableName(_izContext, 'WebSocketTask'),
+          { taskKey: task.taskKey, connectionId: task.connectionId }
+        );
+      })
+    );
   } catch (error) {
     _izContext.logger.error('error WebSocketInvoke: ', error);
     throw error;

package/src/emit/system/templates/WebSocketConnect.ejs

@@ -1,19 +1,39 @@
 import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
-import { middlewareHandler as middleware, response } from '@izara_project/izara-middleware';
+import {
+  middlewareHandler as middleware,
+  response
+} from '@izara_project/izara-middleware';
 
-export const main = middleware.wrap(async event => {
+export const main = middleware.wrap(async (event) => {
   const { eventType, connectionId } = event.requestContext ?? {};
   try {
     event._izContext.logger.debug('Event:', event);
     if (eventType === 'CONNECT') {
       const { userId, submittedByUserId } = event.queryStringParameters ?? {};
-      await dynamodbSharedLib.putItem(event._izContext, await dynamodbSharedLib.tableName(event._izContext, 'UserUploadRecords'), {
-        connectionId, userId, submittedByUserId, expirationTime: Math.floor(Date.now() / 1000) + 7200
-      });
+      await dynamodbSharedLib.putItem(
+        event._izContext,
+        await dynamodbSharedLib.tableName(
+          event._izContext,
+          'UserUploadRecords'
+        ),
+        {
+          connectionId,
+          userId,
+          submittedByUserId,
+          expirationTime: Math.floor(Date.now() / 1000) + 7200
+        }
+      );
       //(<webSocketConnect>)
       //(</webSocketConnect>)
     } else if (eventType === 'DISCONNECT') {
-      await dynamodbSharedLib.deleteItem(event._izContext, await dynamodbSharedLib.tableName(event._izContext, 'UserUploadRecords'), { connectionId });
+      await dynamodbSharedLib.deleteItem(
+        event._izContext,
+        await dynamodbSharedLib.tableName(
+          event._izContext,
+          'UserUploadRecords'
+        ),
+        { connectionId }
+      );
       //(<webSocketDisconnect>)
       //(</webSocketDisconnect>)
     }

package/src/generate.js

@@ -42,6 +42,14 @@ import {
   hasSystemWebSocket,
   systemWebSocketManagedPaths
 } from './emit/system/emitSystemWebSocketArtifacts.js';
+import {
+  emitSystemFindDataArtifacts,
+  findDataManagedPaths
+} from './emit/system/emitSystemFindDataArtifacts.js';
+import {
+  emitCoreFunctionArtifacts,
+  coreFunctionManagedPaths
+} from './emit/coreFunction/emitCoreFunctionArtifacts.js';
 
 export async function generate(rootPath, options = {}) {
   const startedAt = Date.now();
@@ -54,14 +62,21 @@ export async function generate(rootPath, options = {}) {
       loadLocalSchemaDirectory(project, 'RelationshipSchemas'),
       loadLocalSchemaDirectory(project, 'FlowSchemas')
     ]);
+    const schemaBucketName =
+      options.schemaBucketName || process.env.iz_serviceSchemaBucketName;
     const objects = await resolveExtendedObjectSchemas(
       rawObjects,
-      options.schemaBucketName
+      schemaBucketName
     );
     logger?.debug?.(
       `[DEBUG] [Generate] STATUS=SCHEMAS_LOADED | objects=${objects.length} relationships=${relationships.length} flows=${flows.length}`
     );
-    const groups = await _emitGroups({ project, objects, relationships, flows });
+    const groups = await _emitGroups({
+      project,
+      objects,
+      relationships,
+      flows
+    });
     logger?.debug?.(
       `[DEBUG] [Generate] STATUS=ARTIFACTS_EMITTED | ${groups.map((group) => `${group.scope}=${group.artifacts.length}`).join(' ')}`
     );
@@ -95,7 +110,7 @@ export async function generate(rootPath, options = {}) {
 }
 
 async function _emitGroups({ project, objects, relationships, flows }) {
-  const [crud, relationship, rbac, system, resource] = await Promise.all([
+  const [crud, relationship, rbac, system, findData, resource, coreFunction] = await Promise.all([
     emitCrudApplicationArtifacts({
       objects,
       flows,
@@ -108,7 +123,9 @@ async function _emitGroups({ project, objects, relationships, flows }) {
     }),
     emitRbacApplicationArtifacts(objects),
     emitSystemWebSocketArtifacts(flows, { includeRelationshipOwnTopic: true }),
-    emitResourceArtifacts({ objects, relationships, flows })
+    emitSystemFindDataArtifacts(objects),
+    emitResourceArtifacts({ objects, relationships, flows }),
+    emitCoreFunctionArtifacts({ project, objects, relationships })
   ]);
   const custom = await emitCustomFlowApplicationArtifacts(flows, {
     systemFunctions: system.functions,
@@ -153,6 +170,11 @@ async function _emitGroups({ project, objects, relationships, flows }) {
       managedPaths: systemWebSocketManagedPaths(),
       artifacts: system.artifacts
     },
+    {
+      scope: 'system-find-data',
+      managedPaths: findDataManagedPaths(),
+      artifacts: findData
+    },
     {
       scope: 'custom-flow-application',
       managedPaths: customFlowApplicationManagedPaths(flows, {
@@ -166,6 +188,11 @@ async function _emitGroups({ project, objects, relationships, flows }) {
       scope: 'shared-resources',
       managedPaths: resourceArtifactPaths,
       artifacts: resource
+    },
+    {
+      scope: 'core-function',
+      managedPaths: coreFunctionManagedPaths,
+      artifacts: coreFunction
     }
   ];
 }

package/src/output/mergeHooks.js

@@ -1,5 +1,5 @@
 import { lstat, readFile } from 'node:fs/promises';
-import { join, sep } from 'node:path';
+import { join } from 'node:path';
 
 export async function mergeHooks(outputRoot, artifacts) {
   return Promise.all(
@@ -11,39 +11,38 @@ export async function mergeHooks(outputRoot, artifacts) {
 }
 
 async function mergeHook(outputRoot, artifact) {
-  const parts = artifact.path.split(sep);
-  const sourceIndex = parts.lastIndexOf('source');
-  if (sourceIndex < 0 || sourceIndex === parts.length - 1) {
+  const matchers = hookMatchers(artifact.path);
+  if (!matchers) {
     return artifact.content;
   }
 
-  const hookPath = join(
-    outputRoot,
-    ...parts.slice(0, sourceIndex),
-    'hook',
-    ...parts.slice(sourceIndex + 1)
-  );
+  const targetPath = join(outputRoot, artifact.path);
+
+  let sourceContent;
   try {
-    if (!(await lstat(hookPath)).isFile()) {
-      return artifact.content;
+    if (!(await lstat(targetPath)).isFile()) {
+      sourceContent = '';
+    } else {
+      sourceContent = await readFile(targetPath, 'utf8');
     }
   } catch (error) {
     if (error.code === 'ENOENT') {
-      return artifact.content;
+      sourceContent = '';
+    } else {
+      throw error;
     }
-    throw error;
   }
 
-  const matchers = hookMatchers(artifact.path);
-  if (!matchers) {
+  if (!sourceContent) {
     return artifact.content;
   }
 
-  const hookContent = await readFile(hookPath, 'utf8');
   return artifact.content.replace(
     matchers.anyTag,
-    (match, tagName) =>
-      hookContent.match(matchers.tagPattern(tagName))?.[0] ?? match
+    (_match, tagName) => {
+      const hookBlock = sourceContent.match(matchers.tagPattern(tagName))?.[0];
+      return hookBlock ?? _match;
+    }
   );
 }
 

package/test/core.test.js

@@ -145,9 +145,9 @@ test('merges preserved hook blocks into staged source without changing the hook'
   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');
+  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 }), [
@@ -159,11 +159,7 @@ test('merges preserved hook blocks into staged source without changing the hook'
   );
 
   assert.equal(
-    await readFile(join(outputPath, 'app/generated/source/example.js'), 'utf8'),
-    '//(<hookCode>)\ncustom();\n//(</hookCode>)\n'
-  );
-  assert.equal(
-    await readFile(hookPath, 'utf8'),
+    await readFile(sourcePath, 'utf8'),
     '//(<hookCode>)\ncustom();\n//(</hookCode>)\n'
   );
 });
@@ -198,11 +194,8 @@ test('rejects a failed output transaction without partial files, hooks, or stagi
   );
   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(
@@ -215,7 +208,6 @@ test('rejects a failed output transaction without partial files, hooks, or stagi
     /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-')