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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.102",
+  "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/coreFunction/templates/InitialSetupRunner_uploadSchema.ejs

@@ -1,4 +1,11 @@
 import initialSetupLib from '@izara_project/izara-core-library-initial-setup';
+import { basicValidatorSchema } from '@izara_project/izara-shared-service-schemas';
+
+if (basicValidatorSchema?.basicFlowSchema?.properties?.event?.items?.enum) {
+  if (!basicValidatorSchema.basicFlowSchema.properties.event.items.enum.includes('dss')) {
+    basicValidatorSchema.basicFlowSchema.properties.event.items.enum.push('dss');
+  }
+}
 
 const SERVICE_TAG = {
   TRANSLATIONS: 'Translations',

package/src/emit/application/coreFunction/templates/UploadSchema_Main.ejs

@@ -16,6 +16,13 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import initialSetupSharedLib from '@izara_project/izara-core-library-initial-setup';
+import { basicValidatorSchema } from '@izara_project/izara-shared-service-schemas';
+
+if (basicValidatorSchema?.basicFlowSchema?.properties?.event?.items?.enum) {
+  if (!basicValidatorSchema.basicFlowSchema.properties.event.items.enum.includes('dss')) {
+    basicValidatorSchema.basicFlowSchema.properties.event.items.enum.push('dss');
+  }
+}
 
 const SERVICE_TAG = {
   TRANSLATIONS: 'Translations',

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/application/crud/templates/CreateEndpoint_Main.ejs

@@ -153,6 +153,10 @@ export default async function <%- flowTag %>(
         requestParams.billable = true;
       }
 
+      //(<rbacUsageValue_<%- flowTag %>>)
+      let usageValue = requestParams.value || requestParams.usageValue || 1;
+      //(</rbacUsageValue_<%- flowTag %>>)
+
       const resultPermissionCheck = await checkRbacPermission(
         _izContext,
         {
@@ -168,6 +172,7 @@ export default async function <%- flowTag %>(
             serviceTag: <%- rbacServiceTags.length === 1 ? rbacServiceTags[0] : `{ ${Object.entries(rbacServiceTagMap).map(([k, v]) => `'${k}': ${v}`).join(', ')} }[requestParams.objectType] || process.env.iz_serviceTag` %>
           },
           requestParams: requestParams,
+          value: usageValue,
           sync: true
         }
       );
@@ -187,6 +192,14 @@ export default async function <%- flowTag %>(
         );
       }
 
+      if (resultPermissionCheck?.uniqueIdentify) {
+        requestParams.reservedUsageId = resultPermissionCheck.uniqueIdentify;
+      }
+      if (resultPermissionCheck?.runningTotalReservedId) {
+        requestParams.runningTotalReservedId =
+          resultPermissionCheck.runningTotalReservedId;
+      }
+
       //(<rbacPublish_<%- flowTag %>>)
       //(</rbacPublish_<%- flowTag %>>)
     }
@@ -275,6 +288,7 @@ export default async function <%- flowTag %>(
       //(</afterBeforeLogical_<%= objectType %>>)
 
       <%_ if (hasOwnTopic) { _%>
+      /*
       // ── ownTopic (async — dispatch to before-hook and await callback) ──────────
       <%_ configs.filter(c => c?.generatedCodeConfig?.invocationType === 'ownTopic' || c?.event?.includes('ownTopic')).forEach(config => { _%>
       let hookPayload_<%= config.flowTag %> = {
@@ -341,6 +355,13 @@ export default async function <%- flowTag %>(
         status: 'pending',
         message: 'Dispatched to BeforeHook'
       };
+      */
+      return await <%- flowTag %>LogicalLib(
+        _izContext,
+        requestParams,
+        callingFlowConfig,
+        foundErrors
+      );
       <%_ } else { _%>
       return await <%- flowTag %>LogicalLib(
         _izContext,

package/src/emit/application/rbac/templates/CancelUsage_Main.ejs

@@ -154,7 +154,7 @@ export default async function CancelUsage(_izContext, requestParams) {
     };
 
     const eventSourceTag =
-      _izContext.izEventSource?.eventSourceTag ||
+      _izContext?.izEventSource?.eventSourceTag ||
       requestParams?.izEventSource?.eventSourceTag;
 
     let isSync = false;
@@ -162,16 +162,17 @@ export default async function CancelUsage(_izContext, requestParams) {
       eventSourceTag === 'DirectInvoke' ||
       eventSourceTag === 'ApiGateway' ||
       eventSourceTag === 'ApiGatewayV2' ||
-      requestParams?.hasOwnProperty('__context__')
+      requestParams?.hasOwnProperty('__context__') ||
+      _izContext?.functionName?.endsWith('HdrInv') ||
+      _izContext?.functionName?.endsWith('HdrApi') ||
+      eventSourceTag !== 'Sqs'
     ) {
       isSync = true;
     }
 
     if (!isSync) {
-      await sns.publishMessage(_izContext, {
-        message: {
-          returnResult
-        },
+      await sns.publishAsync(_izContext, {
+        Message: JSON.stringify({ returnResult }),
         TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
           _izContext,
           'CancelUsage_Out'

package/src/emit/application/rbac/templates/ConfirmUsage_Main.ejs

@@ -178,7 +178,7 @@ export default async function ConfirmUsage(_izContext, requestParams) {
     };
 
     const eventSourceTag =
-      _izContext.izEventSource?.eventSourceTag ||
+      _izContext?.izEventSource?.eventSourceTag ||
       requestParams?.izEventSource?.eventSourceTag;
 
     let isSync = false;
@@ -186,16 +186,17 @@ export default async function ConfirmUsage(_izContext, requestParams) {
       eventSourceTag === 'DirectInvoke' ||
       eventSourceTag === 'ApiGateway' ||
       eventSourceTag === 'ApiGatewayV2' ||
-      requestParams?.hasOwnProperty('__context__')
+      requestParams?.hasOwnProperty('__context__') ||
+      _izContext?.functionName?.endsWith('HdrInv') ||
+      _izContext?.functionName?.endsWith('HdrApi') ||
+      eventSourceTag !== 'Sqs'
     ) {
       isSync = true;
     }
 
     if (!isSync) {
-      await sns.publishMessage(_izContext, {
-        message: {
-          returnResult
-        },
+      await sns.publishAsync(_izContext, {
+        Message: JSON.stringify({ returnResult }),
         TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
           _izContext,
           'ConfirmUsage_Out'

package/src/emit/application/rbac/templates/CreateTargetRole_Main.ejs

@@ -133,8 +133,8 @@ export default async function CreateTargetRole(_izContext, requestParams) {
       }
     }
 
-    await sns.publishMessage(_izContext, {
-      message: { returnResult: { roleId, roleIdKey } },
+    await sns.publishAsync(_izContext, {
+      Message: JSON.stringify({ returnResult: { roleId, roleIdKey } }),
       TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
         _izContext,
         'CreateTargetRole_Out'

package/src/emit/application/rbac/templates/DeleteTargetRole_Main.ejs

@@ -82,8 +82,8 @@ export default async function DeleteTargetRole(_izContext, requestParams) {
       }
     }
 
-    await sns.publishMessage(_izContext, {
-      message: { returnResult: { identifiersConcat, roleIdKey, status: 'deleted' } },
+    await sns.publishAsync(_izContext, {
+      Message: JSON.stringify({ returnResult: { identifiersConcat, roleIdKey, status: 'deleted' } }),
       TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
         _izContext,
         'DeleteTargetRole_Out'

package/src/emit/application/rbac/templates/GetMyPermissions_Main.ejs

@@ -95,8 +95,8 @@ export default async function GetMyPermissions(_izContext, requestParams) {
       permissions: permissionsMap
     };
 
-    await sns.publishMessage(_izContext, {
-      message: { returnResult: result },
+    await sns.publishAsync(_izContext, {
+      Message: JSON.stringify({ returnResult: result }),
       TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
         _izContext,
         'GetMyPermissions_Out'

package/src/emit/application/rbac/templates/GetTargetRole_Main.ejs

@@ -47,8 +47,8 @@ export default async function GetTargetRole(_izContext, requestParams) {
       users: usersResult?.Items || []
     };
 
-    await sns.publishMessage(_izContext, {
-      message: { returnResult: result },
+    await sns.publishAsync(_izContext, {
+      Message: JSON.stringify({ returnResult: result }),
       TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
         _izContext,
         'GetTargetRole_Out'

package/src/emit/application/rbac/templates/ListRbac_Main.ejs

@@ -41,8 +41,8 @@ export default async function <%- flowTag %>(_izContext, requestParams) {
       dynamodbSharedLib.tableName(_izContext, '<%- tableName %>'),
       queryParams
     );
-    await sns.publishMessage(_izContext, {
-      message: { returnResult: { records: resultQuery.Items || [] } },
+    await sns.publishAsync(_izContext, {
+      Message: JSON.stringify({ returnResult: { records: resultQuery.Items || [] } }),
       TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
         _izContext,
         '<%- flowTag %>_Out'

package/src/emit/application/rbac/templates/RbacMutation_Main.ejs

@@ -28,8 +28,8 @@ export default async function <%- flowTag %>(_izContext, requestParams) {
       dynamodbSharedLib.tableName(_izContext, '<%- tableName %>'),
       { <%- fieldList %> }
     );
-    await sns.publishMessage(_izContext, {
-      message: { returnResult: { <%- fieldList %> } },
+    await sns.publishAsync(_izContext, {
+      Message: JSON.stringify({ returnResult: { <%- fieldList %> } }),
       TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
         _izContext,
         '<%- flowTag %>_Out'

package/src/emit/application/rbac/templates/ReservedDynamicUsage_Main.ejs

@@ -197,7 +197,7 @@ export default async function ReservedDynamicUsage(_izContext, requestParams) {
     };
 
     const eventSourceTag =
-      _izContext.izEventSource?.eventSourceTag ||
+      _izContext?.izEventSource?.eventSourceTag ||
       requestParams?.izEventSource?.eventSourceTag;
 
     let isSync = false;
@@ -205,14 +205,17 @@ export default async function ReservedDynamicUsage(_izContext, requestParams) {
       eventSourceTag === 'DirectInvoke' ||
       eventSourceTag === 'ApiGateway' ||
       eventSourceTag === 'ApiGatewayV2' ||
-      requestParams?.hasOwnProperty('__context__')
+      requestParams?.hasOwnProperty('__context__') ||
+      _izContext?.functionName?.endsWith('HdrInv') ||
+      _izContext?.functionName?.endsWith('HdrApi') ||
+      eventSourceTag !== 'Sqs'
     ) {
       isSync = true;
     }
 
     if (!isSync) {
-      await sns.publishMessage(_izContext, {
-        message: { returnResult },
+      await sns.publishAsync(_izContext, {
+        Message: JSON.stringify({ returnResult }),
         TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
           _izContext,
           'ReservedDynamicUsage_Out'

package/src/emit/application/rbac/templates/UpdateTargetRole_Main.ejs

@@ -93,8 +93,8 @@ export default async function UpdateTargetRole(_izContext, requestParams) {
       }
     }
 
-    await sns.publishMessage(_izContext, {
-      message: { returnResult: { roleIdKey, status: 'updated' } },
+    await sns.publishAsync(_izContext, {
+      Message: JSON.stringify({ returnResult: { roleIdKey, status: 'updated' } }),
       TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
         _izContext,
         'UpdateTargetRole_Out'

package/src/emit/application/rbac/templates/UserRoleMutation_Main.ejs

@@ -54,8 +54,8 @@ export default async function <%- flowTag %>(_izContext, requestParams) {
         }
       }
     ]);
-    await sns.publishMessage(_izContext, {
-      message: { returnResult: { userId, roleIdKey } },
+    await sns.publishAsync(_izContext, {
+      Message: JSON.stringify({ returnResult: { userId, roleIdKey } }),
       TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
         _izContext,
         '<%- flowTag %>_Out'

package/src/emit/infrastructure/resources/sqsResourceArtifacts.js

@@ -102,7 +102,8 @@ export async function renderOut(state) {
       renderResourceTemplate('FlowOut_Yaml.ejs', { topicName })
     )
   );
-  const body = renderedTopics.join('\n');
+  const fileHook = '#<#customTopicOut#>\n#<#/customTopicOut#>';
+  const body = [...renderedTopics, fileHook].filter(Boolean).join('\n');
   return `Resources:\n${indentYaml(body, 2)}`;
 }
 

package/src/emit/infrastructure/resources/templates/FlowOut_Yaml.ejs

@@ -4,3 +4,5 @@ Out<%- topicName %>:
   Properties:
     DisplayName: 'SNS Message out'
     TopicName: ${self:custom.iz_serviceTag}_${self:custom.iz_stage}_<%- topicName %>_Out
+#<#Out<%- topicName %>TopicSetting#>
+#<#/Out<%- topicName %>TopicSetting#>

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/infrastructure/resourceArtifacts.test.js

@@ -964,3 +964,23 @@ test('roleStatements emits s3:GetObject for custom S3 flow bucket', async () =>
   assert.match(uploadRole, /arn:aws:s3:::UploadBucket\/\*/);
 });
 
+test('emits per-topic hook tags in generated-sns-out.yml', async () => {
+  const rootPath = await createProject();
+  await generateResourceArtifacts(rootPath);
+  const snsOut = await readFile(
+    join(rootPath, 'resource/sls_yaml/generatedCode/source/generated-sns-out.yml'),
+    'utf8'
+  );
+  assert.match(snsOut, /#<#Out\w+TopicSetting#>\s*#<#\/Out\w+TopicSetting#>/);
+});
+
+test('emits customTopicOut file-level hook in generated-sns-out.yml', async () => {
+  const rootPath = await createProject();
+  await generateResourceArtifacts(rootPath);
+  const snsOut = await readFile(
+    join(rootPath, 'resource/sls_yaml/generatedCode/source/generated-sns-out.yml'),
+    'utf8'
+  );
+  assert.match(snsOut, /#<#customTopicOut#>\s*#<#\/customTopicOut#>/);
+});
+

package/test/unit/output/mergeHooks.test.js

@@ -402,4 +402,53 @@ test('warns when source content contains custom code in hook missing from templa
   }
 });
 
+test('preserves custom settings inside Out<topicName>TopicSetting and customTopicOut in generated-sns-out.yml', async () => {
+  const tmpDir = await mkdtemp(path.join(os.tmpdir(), 'mergeHooks-test-'));
+  try {
+    const filePath = 'resource/sls_yaml/generatedCode/source/generated-sns-out.yml';
+    const diskContent = [
+      'Resources:',
+      '  ##===== [Topic Out]',
+      '  OutCreate:',
+      '    Type: AWS::SNS::Topic',
+      '    Properties:',
+      "      DisplayName: 'SNS Message out'",
+      '      TopicName: ${self:custom.iz_serviceTag}_${self:custom.iz_stage}_Create_Out',
+      '  #<#OutCreateTopicSetting#>',
+      '    FifoTopic: true',
+      '  #<#/OutCreateTopicSetting#>',
+      '',
+      '  #<#customTopicOut#>',
+      '  OutCustomNotification:',
+      '    Type: AWS::SNS::Topic',
+      '  #<#/customTopicOut#>'
+    ].join('\n') + '\n';
+    await writeTestFile(tmpDir, filePath, diskContent);
+
+    const generatedArtifact = {
+      path: filePath,
+      content: [
+        'Resources:',
+        '  ##===== [Topic Out]',
+        '  OutCreate:',
+        '    Type: AWS::SNS::Topic',
+        '    Properties:',
+        "      DisplayName: 'SNS Message out'",
+        '      TopicName: ${self:custom.iz_serviceTag}_${self:custom.iz_stage}_Create_Out',
+        '  #<#OutCreateTopicSetting#>',
+        '  #<#/OutCreateTopicSetting#>',
+        '',
+        '  #<#customTopicOut#>',
+        '  #<#/customTopicOut#>'
+      ].join('\n') + '\n'
+    };
+
+    const [result] = await mergeHooks(tmpDir, [generatedArtifact]);
+    assert.match(result.content, /FifoTopic: true/);
+    assert.match(result.content, /OutCustomNotification:/);
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true });
+  }
+});
+
 

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