@izara_project/izara-core-generate-service-code 1.0.103 → 1.0.104

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.103",
+  "version": "1.0.104",
   "description": "Code for locally generating per service files",
   "homepage": "https://bitbucket.org/izara-core-support-services/izara-core-support-services-generate-service-code#readme",
   "repository": {

package/src/compile/loadSchemas.js

@@ -99,6 +99,53 @@ export async function loadLocalSchemaDirectory(
     );
     if (loadedSchemas.length === 0) continue;
 
+    if (directoryName === 'ObjectSchemas') {
+      for (let i = 0; i < loadedSchemas.length; i++) {
+        let schema = loadedSchemas[i];
+        if (
+          schema &&
+          typeof schema === 'object' &&
+          'result' in schema &&
+          schema.result &&
+          typeof schema.result === 'object'
+        ) {
+          schema = schema.result;
+          loadedSchemas[i] = schema;
+        }
+        if (!Object.prototype.hasOwnProperty.call(schema, '_sourceFile')) {
+          Object.defineProperty(schema, '_sourceFile', {
+            value: entry.name,
+            enumerable: false,
+            writable: true,
+            configurable: true
+          });
+        }
+        if (
+          !schema.objectType ||
+          typeof schema.objectType !== 'string' ||
+          schema.objectType.trim() === ''
+        ) {
+          const keys = Object.keys(schema || {});
+          let hint = '';
+          if (
+            keys.length === 1 &&
+            typeof schema[keys[0]] === 'object' &&
+            schema[keys[0]] !== null
+          ) {
+            const outerKey = keys[0];
+            hint =
+              ` Schema appears to be wrapped in key '${outerKey}'. ` +
+              `ObjectSchemas must not wrap with the object name; ` +
+              `export [{ objectType: '${outerKey}', ... }] directly.`;
+          }
+          throw new Error(
+            `Invalid ObjectSchema in ${entry.name}: 'objectType' is required ` +
+              `and must be a non-empty string.${hint}`
+          );
+        }
+      }
+    }
+
     if (directoryName === 'ErrorSchemas') {
       for (const schema of loadedSchemas) {
         if (!schema._sourceFile) {

package/src/compile/loadSchemasRemote.js

@@ -20,11 +20,13 @@ const consoleLogger = {
  */
 export async function resolveExtendedObjectSchemas(
   objectSchemas,
-  bucketName = process.env.iz_serviceSchemaBucketName
+  bucketName = process.env.iz_serviceSchemaBucketName,
+  dependencies = {}
 ) {
   if (!Array.isArray(objectSchemas)) {
     throw new TypeError('objectSchemas must be an array');
   }
+  const getObjectSchemaLib = dependencies.getObjectSchema || getObjectSchema;
   const resolvedSchemas = [];
   for (const schema of objectSchemas) {
     let currentSchema = schema;
@@ -36,15 +38,31 @@ export async function resolveExtendedObjectSchemas(
           { extendObjType: currentSchema.extendObjType }
         );
         const initialResources = currentSchema.storageResources || {};
-        const childStorageResourceKeys = new Set(Object.keys(initialResources));
+        const initialResourceKeys = Object.keys(initialResources);
+        const childStorageResourceKeys = new Set(initialResourceKeys);
         const parentServiceTag = currentSchema.extendObjType.serviceTag;
 
-        const mergedSchema = await getObjectSchema.mergeExtendObjSchema(
+        const mergeResult = await getObjectSchemaLib.mergeExtendObjSchema(
           { logger: consoleLogger },
           currentSchema,
           bucketName
         );
 
+        if (
+          mergeResult &&
+          typeof mergeResult === 'object' &&
+          Array.isArray(mergeResult.errorsFound) &&
+          mergeResult.errorsFound.length > 0
+        ) {
+          const errMsg = mergeResult.errorsFound.join('; ');
+          throw new Error(
+            `[resolveExtendedObjectSchemas] Failed to merge extendObjType ` +
+              `for objectType=${currentSchema.objectType}: ${errMsg}`
+          );
+        }
+
+        const mergedSchema = _unwrapSchemaResult(mergeResult);
+
         const externalDynamoResources = [];
         const ownStorageResources = {};
         const mergedStorageResources = mergedSchema.storageResources || {};
@@ -102,12 +120,13 @@ export async function resolveExtendedObjectSchemas(
             serviceTag: belongToTarget.serviceTag,
             objectType: belongToTarget.objectType
           };
-          const belongToSchema = await getObjectSchema.getObjSchemaS3(
+          const belongToResult = await getObjectSchemaLib.getObjSchemaS3(
             { logger: consoleLogger },
             belongToObjType,
             false,
             bucketName
           );
+          const belongToSchema = _unwrapSchemaResult(belongToResult);
           currentSchema.belongToSchema = belongToSchema;
           console.log(
             `[DEBUG] [resolveExtendedObjectSchemas] Successfully fetched ` +
@@ -124,11 +143,26 @@ export async function resolveExtendedObjectSchemas(
       }
     }
 
+    currentSchema = _unwrapSchemaResult(currentSchema);
     resolvedSchemas.push(currentSchema);
   }
   return resolvedSchemas;
 }
 
+function _unwrapSchemaResult(schemaOrResult) {
+  if (!schemaOrResult || typeof schemaOrResult !== 'object') {
+    return schemaOrResult;
+  }
+  if (
+    'result' in schemaOrResult &&
+    schemaOrResult.result &&
+    typeof schemaOrResult.result === 'object'
+  ) {
+    return schemaOrResult.result;
+  }
+  return schemaOrResult;
+}
+
 export async function resolveGraphServiceTags(
   schemas,
   bucketName = process.env.iz_serviceSchemaBucketName

package/src/compile/schemaValidatorSetup.js

@@ -144,6 +144,9 @@ export function setupBasicValidatorSchema(targetSchema = basicValidatorSchema) {
             item.required = item.required.filter((r) => r !== 'billalble');
           }
         }
+        if (item?.properties?.type?.enum?.includes('ledger')) {
+          item.properties.entryObject = { type: 'boolean' };
+        }
       }
     }
   }

package/src/emit/application/crud/emitCrudApplicationArtifacts.js

@@ -29,6 +29,19 @@ export async function emitCrudApplicationArtifacts({
   if (!Array.isArray(objects) || !Array.isArray(flows)) {
     throw new TypeError('objects and flows must be arrays');
   }
+  const malformedObj = objects.find(
+    (obj) =>
+      !obj ||
+      typeof obj.objectType !== 'string' ||
+      obj.objectType.trim() === ''
+  );
+  if (malformedObj) {
+    throw new Error(
+      `[CRUD Application] Malformed ObjectSchema: 'objectType' is required ` +
+        `and must be a non-empty string.`
+    );
+  }
+
   if (!objects.some(isCrudObject)) {
     if (objects.length > 0) {
       const summary = objects.map((obj) => ({

package/src/emit/application/crud/emitDynamicCrudFlowSchemas.js

@@ -23,6 +23,19 @@ export function emitDynamicCrudFlowSchemas({
   if (!Array.isArray(objects) || !Array.isArray(flows)) {
     throw new TypeError('objects and flows must be arrays');
   }
+  const malformedObj = objects.find(
+    (obj) =>
+      !obj ||
+      typeof obj.objectType !== 'string' ||
+      obj.objectType.trim() === ''
+  );
+  if (malformedObj) {
+    throw new Error(
+      `[CRUD FlowSchemas] Malformed ObjectSchema: 'objectType' is required ` +
+        `and must be a non-empty string.`
+    );
+  }
+
   if (!objects.some(isCrudObject)) {
     if (objects.length > 0) {
       const summary = objects.map((obj) => ({

package/src/emit/schemas/ledger/emitLedgerSchemas.js

@@ -126,7 +126,6 @@ function _buildParentToEntryLinks({
           objectType: parentObjectType
         },
         linkType: 'many',
-        requiredOnCreate: false,
         belongTo: true
       },
       to: {
@@ -134,8 +133,7 @@ function _buildParentToEntryLinks({
           serviceTag: effectiveServiceTag,
           objectType: entryObjectType
         },
-        linkType: 'one',
-        requiredOnCreate: false
+        linkType: 'one'
       }
     }
   ];
@@ -145,7 +143,10 @@ export function ledgerObjectSchemaManagedPaths(objects = []) {
   const ledgers = _extractLedgers(objects);
   const paths = [];
 
-  for (const { component } of ledgers) {
+  for (const { component, addOn } of ledgers) {
+    if (addOn?.entryObject === false) {
+      continue;
+    }
     paths.push(
       `app/src/schemas/ObjectSchemas/generatedLedger/${component.objectType}.js`
     );
@@ -198,6 +199,9 @@ export async function emitLedgerObjectSchemas({ objects = [] } = {}) {
   const artifacts = [];
 
   for (const { parentObject, addOn, component } of ledgers) {
+    if (addOn?.entryObject === false) {
+      continue;
+    }
     const objectType = component.objectType;
     const graphStorageResources = _extractGraphStorageResources(
       parentObject,
@@ -362,16 +366,14 @@ export async function emitLedgerRelationshipSchemas({
               serviceTag: effectiveServiceTag,
               objectType: component.objectType
             },
-            linkType: 'many',
-            requiredOnCreate: false
+            linkType: 'many'
           },
           to: {
             objType: {
               serviceTag: targetServiceTag,
               objectType: target.objectType
             },
-            linkType: 'one',
-            requiredOnCreate: false
+            linkType: 'one'
           }
         });
       }

package/src/emit/schemas/ledger/templates/LedgerObjectSchema.ejs

@@ -1,3 +1,19 @@
 export default [
-  <%- JSON.stringify(schema, null, 2).replace(/\n/g, '\n  ') %>
+  {
+    "objectType": "<%= schema.objectType %>",
+    "generatedBy": "systemNoUser",
+    "canDelete": false,
+    "storageResources": <%- JSON.stringify(schema.storageResources, null, 4).replace(/\n/g, '\n    ') %>,
+    "fieldNames": {
+      "<%= schema.objectType %>Id": <%- JSON.stringify(schema.fieldNames[schema.objectType + 'Id'], null, 6).replace(/\n/g, '\n      ') %>,
+      //(<<%= schema.objectType %>HookCode>)
+      //(</<%= schema.objectType %>HookCode>)
+    },
+    "identifiers": [
+      {
+        "type": "identifier",
+        "fieldName": "<%= schema.objectType %>Id"
+      }
+    ]
+  }
 ];

package/src/emit/schemas/ledger/templates/LedgerRelationshipSchema.ejs

@@ -1 +1,11 @@
-export default <%- JSON.stringify(wrapper, null, 2) %>;
+export default [
+  {
+    "<%= relationshipTag %>": {
+<% Object.entries(content).forEach(([key, val]) => { -%>
+      "<%- key %>": <%- JSON.stringify(val, null, 6).replace(/\n/g, '\n      ') %>,
+<% }); -%>
+      //(<<%= relationshipTag %>HookCode>)
+      //(</<%= relationshipTag %>HookCode>)
+    }
+  }
+];

package/src/generate.js

@@ -42,10 +42,22 @@ export async function generate(rootPath, options = {}) {
       options.schemaBucketName ||
       project.schemaBucketName ||
       process.env.iz_serviceSchemaBucketName;
-    const objects = await resolveExtendedObjectSchemas(
+    const resolvedObjects = await resolveExtendedObjectSchemas(
       rawObjects,
       schemaBucketName
     );
+    const objects = resolvedObjects.map((obj) => {
+      if (
+        obj &&
+        typeof obj === 'object' &&
+        'result' in obj &&
+        obj.result &&
+        typeof obj.result === 'object'
+      ) {
+        return obj.result;
+      }
+      return obj;
+    });
     const objectGraphServiceTags = await resolveGraphServiceTags(
       objects,
       schemaBucketName
@@ -93,16 +105,35 @@ export async function generate(rootPath, options = {}) {
     console.log(
       `[INFO] [Generate] STATUS=ARTIFACTS_EMITTED | ${emittedScopeSummary}`
     );
+    const allArtifacts = groups.flatMap((group) => group.artifacts);
+    const dirSummary = _summarizeArtifactDirectories(allArtifacts);
+    const summaryEntries = Object.entries(dirSummary);
+    if (summaryEntries.length > 0) {
+      const summaryItems = summaryEntries
+        .map(([dir, count]) => `${dir}=${count}`)
+        .join(' ');
+      console.log(`[INFO] [Generate] OUTPUT_SUMMARY | ${summaryItems}`);
+    }
     let files = [];
     if (groups.length > 0) {
       files = await commitArtifacts(
         buildGenerationPlan(
           project,
-          groups.flatMap((group) => group.artifacts),
+          allArtifacts,
           {
             managedScopes: Object.fromEntries(
               groups.map((group) => [group.scope, group.managedPaths])
-            )
+            ),
+            scopeGuards: {
+              hasMalformedSchemas:
+                objects.some(
+                  (obj) =>
+                    !obj ||
+                    typeof obj.objectType !== 'string' ||
+                    obj.objectType.trim() === ''
+                ) ||
+                relationships.some((rel) => !rel || typeof rel !== 'object')
+            }
           }
         )
       );
@@ -123,3 +154,19 @@ export async function generate(rootPath, options = {}) {
     throw error;
   }
 }
+
+function _summarizeArtifactDirectories(artifacts) {
+  const dirCounts = {};
+  for (const artifact of artifacts) {
+    const parts = artifact.path.split('/');
+    let category = parts.slice(0, 3).join('/');
+    if (parts.length < 3) {
+      category = parts.slice(0, -1).join('/');
+      if (!category) {
+        category = '.';
+      }
+    }
+    dirCounts[category] = (dirCounts[category] || 0) + 1;
+  }
+  return dirCounts;
+}

package/src/output/commitArtifacts.js

@@ -42,8 +42,17 @@ export async function commitArtifacts(plan) {
   const stalePaths = _staleManagedPaths(
     managedScopes,
     managedArtifacts,
-    artifacts
+    artifacts,
+    plan.scopeGuards
   );
+  if (stalePaths.length > 0) {
+    console.log(
+      `[WARN] [Commit] REMOVED_STALE | count=${stalePaths.length} files:`
+    );
+    for (const path of stalePaths) {
+      console.log(`  - ${path}`);
+    }
+  }
   const mergedArtifacts = await mergeHooks(physicalOutputRoot, artifacts);
   const stagedRoot = await mkdtemp(join(physicalOutputRoot, STAGING_PREFIX));
 
@@ -67,6 +76,10 @@ export async function commitArtifacts(plan) {
     const snapshots = await _snapshotChanges(changes, stagedRoot);
     try {
       await _applyChanges(changes);
+      console.log(
+        `[INFO] [Commit] STATUS=APPLIED | written=${artifacts.length} ` +
+          `removed=${stalePaths.length}`
+      );
     } catch (error) {
       await _rollbackChanges(changes, snapshots);
       throw error;
@@ -90,7 +103,12 @@ function _normalizeManagedScopes(plan) {
   };
 }
 
-function _staleManagedPaths(managedScopes, managedArtifacts, artifacts) {
+function _staleManagedPaths(
+  managedScopes,
+  managedArtifacts,
+  artifacts,
+  scopeGuards
+) {
   if (!managedScopes) {
     return [];
   }
@@ -100,7 +118,28 @@ function _staleManagedPaths(managedScopes, managedArtifacts, artifacts) {
     if (!Object.hasOwn(managedArtifacts, scope)) {
       continue;
     }
-    for (const path of [...declaredPaths, ...managedArtifacts[scope]]) {
+    const previousPaths = managedArtifacts[scope] || [];
+    if (previousPaths.length > 0) {
+      const scopeEmittedCount = declaredPaths.filter((path) =>
+        emittedPaths.has(path)
+      ).length;
+      if (scopeEmittedCount === 0) {
+        if (scopeGuards?.hasMalformedSchemas) {
+          throw new Error(
+            `[SAFETY_GUARD] Refusing to delete all artifacts in managed ` +
+              `scope '${scope}'. Malformed schemas were detected in the ` +
+              `project.`
+          );
+        }
+        if (scopeGuards?.protectedScopes?.includes(scope)) {
+          throw new Error(
+            `[SAFETY_GUARD] Refusing to delete all artifacts in protected ` +
+              `scope '${scope}'.`
+          );
+        }
+      }
+    }
+    for (const path of [...declaredPaths, ...previousPaths]) {
       if (!emittedPaths.has(path)) {
         stalePaths.add(path);
       }

package/src/plan/buildGenerationPlan.js

@@ -6,7 +6,7 @@ import {
 export function buildGenerationPlan(
   project,
   artifacts = [],
-  { managedPaths = [], managedScope, managedScopes } = {}
+  { managedPaths = [], managedScope, managedScopes, scopeGuards } = {}
 ) {
   if (!project?.rootPath || !project?.outputPath) {
     throw new TypeError('ProjectModel must include rootPath and outputPath');
@@ -21,7 +21,8 @@ export function buildGenerationPlan(
     artifacts: validateArtifacts(artifacts),
     managedPaths: normalizeArtifactPaths(managedPaths),
     managedScope: _normalizeManagedScope(managedScope),
-    managedScopes: _normalizeManagedScopes(managedScopes)
+    managedScopes: _normalizeManagedScopes(managedScopes),
+    scopeGuards: scopeGuards ? Object.freeze({ ...scopeGuards }) : null
   });
 }
 

package/test/integration/core.test.js

@@ -229,3 +229,34 @@ test('rejects a failed output transaction without partial files, hooks, or stagi
   );
   assert.equal((await readdir(outputPath)).includes('.bak'), false);
 });
+
+test('commitArtifacts throws SAFETY_GUARD error when hasMalformedSchemas is true and scope would be wiped', async () => {
+  const outputPath = await mkdtemp(
+    join(tmpdir(), 'generate-service-code-v2-safety-guard-')
+  );
+  const project = compileProject({ rootPath: outputPath });
+  const managedScopes = {
+    'crud-application': ['app/sls_yaml/generatedCode/source/flow-objects.yml']
+  };
+  await commitArtifacts(
+    buildGenerationPlan(
+      project,
+      [{ path: 'app/sls_yaml/generatedCode/source/flow-objects.yml', content: 'content\n' }],
+      { managedScopes }
+    )
+  );
+
+  await assert.rejects(
+    commitArtifacts(
+      buildGenerationPlan(project, [], {
+        managedScopes,
+        scopeGuards: { hasMalformedSchemas: true }
+      })
+    ),
+    /\[SAFETY_GUARD\] Refusing to delete all artifacts in managed scope 'crud-application'/
+  );
+  assert.equal(
+    await readFile(join(outputPath, 'app/sls_yaml/generatedCode/source/flow-objects.yml'), 'utf8'),
+    'content\n'
+  );
+});

package/test/unit/application/crudApplicationArtifacts.test.js

@@ -8,6 +8,7 @@ import test, { after } from 'node:test';
 process.env.NODE_ENV = 'test';
 
 import { generateCrudApplicationArtifacts } from '../../../src/emit/application/crud/generateCrudApplicationArtifacts.js';
+import { emitCrudApplicationArtifacts } from '../../../src/emit/application/crud/emitCrudApplicationArtifacts.js';
 
 const roots = new Set();
 after(() =>
@@ -1464,6 +1465,15 @@ test('emits async before-hook callback and SNS publish in Create_Main when event
   assert.match(callbackHandler, /CreateBeforeHookCallback_Main/);
 });
 
+test('emitCrudApplicationArtifacts throws error when an object is malformed', async () => {
+  await assert.rejects(
+    emitCrudApplicationArtifacts({
+      objects: [{ generatedBy: 'user' }]
+    }),
+    /Malformed ObjectSchema: 'objectType' is required/
+  );
+});
+
 async function createProject(withCrudObject) {
   const rootPath = await mkdtemp(
     join(tmpdir(), 'generate-service-code-v2-crud-application-')

package/test/unit/schemas/dynamicCrudFlowSchemas.test.js

@@ -6,6 +6,7 @@ import test from 'node:test';
 import { pathToFileURL } from 'node:url';
 
 import { generateDynamicCrudFlowSchemas } from '../../../src/emit/application/crud/generateDynamicCrudFlowSchemas.js';
+import { emitDynamicCrudFlowSchemas } from '../../../src/emit/application/crud/emitDynamicCrudFlowSchemas.js';
 import { createCrudActionPlans } from '../../../src/emit/application/crud/crudActionPlan.js';
 
 test('generates dynamic CRUD schemas from local schema modules', async () => {
@@ -422,3 +423,39 @@ test('throws error when ObjectSchema validation fails with validateSchemas: true
   );
 });
 
+test('throws error when ObjectSchema is missing objectType', async () => {
+  const rootPath = await createProject({ generatedBy: 'user' });
+  await writeFile(
+    join(rootPath, 'app/src/schemas/ObjectSchemas/Order.js'),
+    "export default [{ generatedBy: 'user' }];\n"
+  );
+
+  await assert.rejects(
+    generateDynamicCrudFlowSchemas(rootPath),
+    /Invalid ObjectSchema in Order\.js: 'objectType' is required/
+  );
+});
+
+test('throws helpful error when ObjectSchema is wrapped in outer key', async () => {
+  const rootPath = await createProject({ generatedBy: 'user' });
+  await writeFile(
+    join(rootPath, 'app/src/schemas/ObjectSchemas/Order.js'),
+    "export default [{ order: { objectType: 'order', generatedBy: 'user' } }];\n"
+  );
+
+  await assert.rejects(
+    generateDynamicCrudFlowSchemas(rootPath),
+    /Schema appears to be wrapped in key 'order'/
+  );
+});
+
+test('emitDynamicCrudFlowSchemas throws error when an object is malformed', () => {
+  assert.throws(
+    () =>
+      emitDynamicCrudFlowSchemas({
+        objects: [{ generatedBy: 'user' }]
+      }),
+    /Malformed ObjectSchema: 'objectType' is required/
+  );
+});
+

package/test/unit/schemas/ledgerSchemas.test.js

@@ -79,6 +79,10 @@ test('emitLedgerObjectSchemas returns 1 object schema per ledger addOn', async (
   assert.match(entryArtifact.content, /"generatedBy": "systemNoUser"/);
   assert.match(entryArtifact.content, /"canDelete": false/);
   assert.match(entryArtifact.content, /GraphHandler/);
+  assert.match(
+    entryArtifact.content,
+    /\/\/\(<unitStandardSupplyLocationEntryHookCode>\)[\s\S]*?\/\/\(<\/unitStandardSupplyLocationEntryHookCode>\)/
+  );
 });
 
 test('emitLedgerRelationshipSchemas returns current, old, and is relationship schemas per ledger addOn', async () => {
@@ -157,30 +161,46 @@ test('emitLedgerRelationshipSchemas returns current, old, and is relationship sc
   assert.match(isRel.content, /"supplyLocation"/);
   assert.match(isRel.content, /"unitPacking"/);
 
-  // 4. Verify requiredOnCreate is false in links
+  // 4. Verify hookCode in relationship schemas
+  assert.match(
+    currentRel.content,
+    /\/\/\(<currentUnitStandardSupplyLocationHookCode>\)[\s\S]*?\/\/\(<\/currentUnitStandardSupplyLocationHookCode>\)/
+  );
+  assert.match(
+    oldRel.content,
+    /\/\/\(<oldUnitStandardSupplyLocationHookCode>\)[\s\S]*?\/\/\(<\/oldUnitStandardSupplyLocationHookCode>\)/
+  );
+  assert.match(
+    isRel.content,
+    /\/\/\(<isUnitStandardSupplyLocationEntryHookCode>\)[\s\S]*?\/\/\(<\/isUnitStandardSupplyLocationEntryHookCode>\)/
+  );
+
+  // 5. Verify requiredOnCreate is removed from links
   const _parseRel = (content) => {
     const raw = content
       .replace(/^export default\s+/, '')
-      .replace(/;\s*$/, '');
+      .replace(/;\s*$/, '')
+      .replace(/\/\/.*/g, '')
+      .replace(/,(\s*})/g, '$1');
     return JSON.parse(raw)[0];
   };
 
   const currentRelData = Object.values(_parseRel(currentRel.content))[0];
   for (const link of currentRelData.links) {
-    assert.equal(link.from.requiredOnCreate, false);
-    assert.equal(link.to.requiredOnCreate, false);
+    assert.equal(link.from.requiredOnCreate, undefined);
+    assert.equal(link.to.requiredOnCreate, undefined);
   }
 
   const oldRelData = Object.values(_parseRel(oldRel.content))[0];
   for (const link of oldRelData.links) {
-    assert.equal(link.from.requiredOnCreate, false);
-    assert.equal(link.to.requiredOnCreate, false);
+    assert.equal(link.from.requiredOnCreate, undefined);
+    assert.equal(link.to.requiredOnCreate, undefined);
   }
 
   const isRelData = Object.values(_parseRel(isRel.content))[0];
   for (const link of isRelData.links) {
-    assert.equal(link.from.requiredOnCreate, false);
-    assert.equal(link.to.requiredOnCreate, false);
+    assert.equal(link.from.requiredOnCreate, undefined);
+    assert.equal(link.to.requiredOnCreate, undefined);
   }
 });
 
@@ -221,10 +241,122 @@ test('generate commits and cleans up ledger dynamic schemas', async () => {
   });
 });
 
+test('generate preserves user hooks in ledger ObjectSchemas and RelationshipSchemas across regeneration', async () => {
+  const rootPath = await createProjectWithLedger({ hasAddOn: true });
+  await generate(rootPath);
+
+  const objectRelPath =
+    'app/src/schemas/ObjectSchemas/generatedLedger/unitStandardSupplyLocationEntry.js';
+  const relRelPath =
+    'app/src/schemas/RelationshipSchemas/generatedLedger/currentUnitStandardSupplyLocation.js';
+
+  // Inject custom code into dynamic hook tags
+  let objectContent = await readProjectFile(rootPath, objectRelPath);
+  objectContent = objectContent.replace(
+    '//(<unitStandardSupplyLocationEntryHookCode>)\n      //(</unitStandardSupplyLocationEntryHookCode>)',
+    '//(<unitStandardSupplyLocationEntryHookCode>)\n      "customField": { "type": "string" },\n      //(</unitStandardSupplyLocationEntryHookCode>)'
+  );
+  await writeProjectFile(rootPath, objectRelPath, objectContent);
+
+  let relContent = await readProjectFile(rootPath, relRelPath);
+  relContent = relContent.replace(
+    '//(<currentUnitStandardSupplyLocationHookCode>)\n      //(</currentUnitStandardSupplyLocationHookCode>)',
+    '//(<currentUnitStandardSupplyLocationHookCode>)\n      "customRelProp": true,\n      //(</currentUnitStandardSupplyLocationHookCode>)'
+  );
+  await writeProjectFile(rootPath, relRelPath, relContent);
+
+  // Re-run generate
+  await generate(rootPath);
+
+  const preservedObjectContent = await readProjectFile(rootPath, objectRelPath);
+  assert.match(preservedObjectContent, /"customField": \{ "type": "string" \}/);
+
+  const preservedRelContent = await readProjectFile(rootPath, relRelPath);
+  assert.match(preservedRelContent, /"customRelProp": true/);
+});
+
+test('emitLedgerObjectSchemas and managedPaths skip when entryObject is false', async () => {
+  const objects = [
+    {
+      objectType: 'unitStandard',
+      serviceTag: 'UnitStandard',
+      storageResources: {
+        graph: {
+          storageType: 'graph',
+          graphServerTag: 'GraphHandler'
+        }
+      },
+      addOnDataStructure: [
+        {
+          type: 'ledger',
+          prefix: 'unitStandardSupplyLocation',
+          storageResourceTag: 'graph',
+          ledgerType: 'movable',
+          entryObject: false,
+          targetObjType: {
+            serviceTag: 'SupplyLocationStandard',
+            objectType: 'supplyLocation'
+          }
+        }
+      ]
+    }
+  ];
+
+  const artifacts = await emitLedgerObjectSchemas({ objects });
+  assert.equal(artifacts.length, 0);
+
+  const managedPaths = ledgerObjectSchemaManagedPaths(objects);
+  assert.deepEqual(managedPaths, []);
+
+  const relArtifacts = await emitLedgerRelationshipSchemas({
+    objects,
+    serviceTag: 'UnitStandard'
+  });
+  assert.equal(relArtifacts.length, 3);
+  const relPaths = ledgerRelationshipSchemaManagedPaths(objects);
+  assert.equal(relPaths.length, 3);
+});
+
+test('generate cleans up entry ObjectSchema when entryObject is set to false', async () => {
+  const rootPath = await createProjectWithLedger({
+    hasAddOn: true,
+    entryObject: true
+  });
+  await generate(rootPath);
+
+  const objectRelPath =
+    'app/src/schemas/ObjectSchemas/generatedLedger/unitStandardSupplyLocationEntry.js';
+  const relRelPath =
+    'app/src/schemas/RelationshipSchemas/generatedLedger/currentUnitStandardSupplyLocation.js';
+
+  const initialObj = await readProjectFile(rootPath, objectRelPath);
+  assert.ok(initialObj);
+  const initialRel = await readProjectFile(rootPath, relRelPath);
+  assert.ok(initialRel);
+
+  await createProjectWithLedger({
+    rootPath,
+    hasAddOn: true,
+    entryObject: false
+  });
+  await generate(rootPath);
+
+  await assert.rejects(readProjectFile(rootPath, objectRelPath), {
+    code: 'ENOENT'
+  });
+  const preservedRel = await readProjectFile(rootPath, relRelPath);
+  assert.ok(preservedRel);
+});
+
 async function createProjectWithLedger({
   rootPath: existingRoot,
-  hasAddOn = true
+  hasAddOn = true,
+  entryObject = true
 } = {}) {
+  let entryObjectLine = '';
+  if (entryObject === false) {
+    entryObjectLine = '\n        entryObject: false,';
+  }
   const addOnContent = hasAddOn
     ? `
     addOnDataStructure: [
@@ -232,7 +364,7 @@ async function createProjectWithLedger({
         type: 'ledger',
         prefix: 'unitStandardSupplyLocation',
         storageResourceTag: 'graph',
-        ledgerType: 'movable',
+        ledgerType: 'movable',${entryObjectLine}
         targetObjType: {
           serviceTag: 'SupplyLocationStandard',
           objectType: 'supplyLocation'

package/test/unit/schemas/resolveExtendedObjectSchemas.test.js

@@ -0,0 +1,136 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  resolveExtendedObjectSchemas
+} from '../../../src/compile/loadSchemasRemote.js';
+
+test(
+  'resolveExtendedObjectSchemas unwraps result from mergeExtendObjSchema',
+  async () => {
+    const mockServiceSchemas = {
+      mergeExtendObjSchema: async () => {
+        return {
+          errorsFound: [],
+          result: {
+            objectType: 'unitStandard',
+            generatedBy: 'user',
+            storageResources: {
+              dynamo1: {
+                tableName: 'UnitStandards',
+                storageType: 'dynamo'
+              },
+              childDynamo: {
+                tableName: 'ChildTable',
+                storageType: 'dynamo'
+              }
+            }
+          }
+        };
+      }
+    };
+
+    const inputSchemas = [
+      {
+        objectType: 'unitStandard',
+        generatedBy: 'user',
+        extendObjType: {
+          serviceTag: 'CoreService',
+          objectType: 'standard'
+        },
+        storageResources: {
+          childDynamo: {
+            tableName: 'ChildTable',
+            storageType: 'dynamo'
+          }
+        }
+      }
+    ];
+
+    const resolved = await resolveExtendedObjectSchemas(
+      inputSchemas,
+      'bucket',
+      { getObjectSchema: mockServiceSchemas }
+    );
+    assert.equal(resolved.length, 1);
+    const resolvedObject = resolved[0];
+    assert.equal(resolvedObject.objectType, 'unitStandard');
+    assert.equal(resolvedObject.result, undefined);
+    assert.equal(resolvedObject.errorsFound, undefined);
+    assert.ok(resolvedObject.storageResources);
+    assert.ok(resolvedObject.storageResources.childDynamo);
+    assert.ok(resolvedObject.externalDynamoResources);
+    assert.equal(resolvedObject.externalDynamoResources.length, 1);
+    assert.equal(
+      resolvedObject.externalDynamoResources[0].tableName,
+      'UnitStandards'
+    );
+  }
+);
+
+test(
+  'resolveExtendedObjectSchemas throws if merge returns errorsFound',
+  async () => {
+    const mockServiceSchemas = {
+      mergeExtendObjSchema: async () => {
+        return {
+          errorsFound: ['Parent schema not found in S3'],
+          result: null
+        };
+      }
+    };
+
+    const inputSchemas = [
+      {
+        objectType: 'unitStandard',
+        extendObjType: {
+          serviceTag: 'CoreService',
+          objectType: 'missing'
+        }
+      }
+    ];
+
+    await assert.rejects(
+      resolveExtendedObjectSchemas(inputSchemas, 'bucket', {
+        getObjectSchema: mockServiceSchemas
+      }),
+      /Parent schema not found in S3/
+    );
+  }
+);
+
+test(
+  'resolveExtendedObjectSchemas unwraps belongToSchema from getObjSchemaS3',
+  async () => {
+    const mockServiceSchemas = {
+      getObjSchemaS3: async () => {
+        return {
+          errorsFound: [],
+          result: {
+            objectType: 'organization',
+            generatedBy: 'user'
+          }
+        };
+      }
+    };
+
+    const inputSchemas = [
+      {
+        objectType: 'member',
+        belongTo: {
+          serviceTag: 'OrgService',
+          objectType: 'organization'
+        }
+      }
+    ];
+
+    const resolved = await resolveExtendedObjectSchemas(
+      inputSchemas,
+      'bucket',
+      { getObjectSchema: mockServiceSchemas }
+    );
+    assert.equal(resolved.length, 1);
+    assert.equal(resolved[0].belongToSchema?.objectType, 'organization');
+    assert.equal(resolved[0].belongToSchema?.result, undefined);
+  }
+);