@izara_project/izara-core-generate-service-code 1.0.82 → 1.0.84

package/src/emit/coreFunction/templates/InitialSetupConfig.ejs

@@ -70,6 +70,10 @@ const externalServices = {
     dynamoTableNames.add('RolePermissions');
     dynamoTableNames.add('RoleUsers');
     dynamoTableNames.add('UserRoles');
+    dynamoTableNames.add('RbacPermissionCaches');
+    dynamoTableNames.add('RoleLimit');
+    dynamoTableNames.add('RunningTotalUsage');
+    dynamoTableNames.add('RunningTotalReservedUsage');
   }
   if (typeof s3Flows !== 'undefined' && (s3Flows || []).length > 0) {
     dynamoTableNames.add('ReservedDataMain');
@@ -176,16 +180,25 @@ const tableConfigs = {
   if (crud && typeof rbacValidatorServiceTags !== 'undefined' && rbacValidatorServiceTags && rbacValidatorServiceTags.length > 0) {
     const allRbacTags = Array.from(new Set(['Rbac', ...rbacValidatorServiceTags]));
     const hasGraph = typeof objectGraphServiceTags !== 'undefined' && objectGraphServiceTags && objectGraphServiceTags.length > 0;
+    const createEndpoint = hasGraph ? 'CreateRbacCallbackHdrSqs' : 'CreateCompleteHdrSqs';
     const updateEndpoint = hasGraph ? 'UpdateRbacCallbackHdrSqs' : 'UpdateCompleteHdrSqs';
     const deleteEndpoint = hasGraph ? 'DeleteRbacCallbackHdrSqs' : 'DeleteCompleteHdrSqs';
     allRbacTags.forEach(function(tag) {
-      if (!hasGraph) {
-        rbacSubs.push({ serviceTag: tag, topicName: 'ValidatorRbac_Out', sqsEndpoint: 'CreateCompleteHdrSqs' });
-      }
+      rbacSubs.push({ serviceTag: tag, topicName: 'ValidatorRbac_Out', sqsEndpoint: createEndpoint });
       rbacSubs.push({ serviceTag: tag, topicName: 'ValidatorRbac_Out', sqsEndpoint: updateEndpoint });
       rbacSubs.push({ serviceTag: tag, topicName: 'ValidatorRbac_Out', sqsEndpoint: deleteEndpoint });
     });
   }
+
+  if (typeof customRbacFlowTags !== 'undefined' && customRbacFlowTags && customRbacFlowTags.length > 0) {
+    const allRbacTags = Array.from(new Set(['Rbac', ...(typeof rbacValidatorServiceTags !== 'undefined' ? rbacValidatorServiceTags : [])]));
+    customRbacFlowTags.forEach(function(flowTag) {
+      const tagUpper = flowTag[0].toUpperCase() + flowTag.slice(1);
+      allRbacTags.forEach(function(tag) {
+        rbacSubs.push({ serviceTag: tag, topicName: 'ValidatorRbac_Out', sqsEndpoint: `${tagUpper}RbacCallbackHdrSqs` });
+      });
+    });
+  }
 -%>
 const snsTopicSubscriptions = [
 <% if (relSubs.length > 0) { -%>

package/src/emit/crud/crudActionPlan.js

@@ -5,37 +5,45 @@ export function createCrudActionPlans(objects = []) {
   const hasRbac = objects.some(
     (object) => isCrudObject(object) && hasRbacObject(object, objects)
   );
+  const isBillable = objects.some(
+    (object) => isCrudObject(object) && isBillableObject(object, objects)
+  );
 
   return Object.fromEntries(
     CRUD_ACTIONS.map((action) => [
       action,
-      createCrudActionPlan(action, { hasGraph, hasRbac })
+      createCrudActionPlan(action, { hasGraph, hasRbac, isBillable })
     ])
   );
 }
 
 export function createCrudActionPlan(
   action,
-  { hasGraph = false, hasRbac = false } = {}
+  { hasGraph = false, hasRbac = false, isBillable = true } = {}
 ) {
-  const actionHasRbac = action !== 'Create' && action !== 'Get' && hasRbac;
+  const actionHasRbac = action !== 'Get' && hasRbac;
   const outputTopic = action !== 'Get';
+  const hasQuotaReservation = action === 'Create' && hasRbac && isBillable;
 
   return {
     action,
     outputTopic,
     hasGraph: outputTopic && hasGraph,
     hasRbac: actionHasRbac,
+    hasQuotaReservation,
     hasComplete: outputTopic && (actionHasRbac || hasGraph),
     hasRbacCallback: outputTopic && actionHasRbac && hasGraph
   };
 }
 
+export const VALID_CRUD_GENERATED_BY = new Set([
+  'user',
+  'systemWithUser',
+  'systemNoUser'
+]);
+
 export function isCrudObject(object) {
-  return (
-    object?.generatedBy === 'userGenerated' ||
-    object?.generatedBy === 'systemGenerated'
-  );
+  return VALID_CRUD_GENERATED_BY.has(object?.generatedBy);
 }
 
 export function hasGraphStorageResource(objects = []) {
@@ -80,3 +88,31 @@ function normalizeBelongTo(object) {
   if (!object?.belongTo) return [];
   return Array.isArray(object.belongTo) ? object.belongTo : [object.belongTo];
 }
+
+export function isBillableObject(object, objects = []) {
+  if (!isCrudObject(object)) return false;
+
+  const targets = normalizeBelongTo(object);
+  if (targets.length > 0) {
+    for (const target of targets) {
+      if (typeof target?.billable === 'boolean') {
+        return target.billable;
+      }
+    }
+  }
+
+  if (Array.isArray(object?.addOnDataStructure)) {
+    const rbacAddOn = object.addOnDataStructure.find(
+      (addOn) => addOn?.type === 'rbac'
+    );
+    if (typeof rbacAddOn?.billable === 'boolean') {
+      return rbacAddOn.billable;
+    }
+  }
+
+  if (typeof object?.billable === 'boolean') {
+    return object.billable;
+  }
+
+  return true;
+}

package/src/emit/crud/emitCrudApplicationArtifacts.js

@@ -11,7 +11,8 @@ import {
 import {
   CRUD_ACTIONS,
   createCrudActionPlans,
-  isCrudObject
+  isCrudObject,
+  VALID_CRUD_GENERATED_BY
 } from './crudActionPlan.js';
 
 const ACTIONS = CRUD_ACTIONS;
@@ -22,12 +23,26 @@ const SHARED_TEMPLATE_URL = new URL('../shared/templates/', import.meta.url);
 export async function emitCrudApplicationArtifacts({
   objects,
   flows = [],
-  serviceTag
+  serviceTag,
+  logger
 }) {
   if (!Array.isArray(objects) || !Array.isArray(flows)) {
     throw new TypeError('objects and flows must be arrays');
   }
-  if (!objects.some(isCrudObject)) return [];
+  if (!objects.some(isCrudObject)) {
+    if (objects.length > 0) {
+      const summary = objects.map((obj) => ({
+        objectType: obj?.objectType ?? '(undefined)',
+        generatedBy: obj?.generatedBy ?? '(missing)'
+      }));
+      logger?.warn?.(
+        `[WARN] [CRUD Application] Skipped FlowObjects application artifacts generation: No valid CRUD ObjectSchema found. ` +
+        `Checked ${objects.length} object(s): ${JSON.stringify(summary)}. ` +
+        `Expected "generatedBy" to be one of: ${Array.from(VALID_CRUD_GENERATED_BY).join(', ')}`
+      );
+    }
+    return [];
+  }
 
   const handlers = await Promise.all(
     ACTIONS.map((action) => emitAction(action, objects, serviceTag))
@@ -87,7 +102,7 @@ async function emitAction(action, objects, serviceTag) {
     flow: null,
     flowStepName: '',
     startConfig: null,
-    objects: action === 'Create' ? [] : objects,
+    objects: objects,
     isCrudObject,
     hasRbacAddOn: (object) => hasRbacAddOn(object, objects),
     plan

package/src/emit/crud/emitDynamicCrudFlowSchemas.js

@@ -3,7 +3,8 @@ import {
   CRUD_ACTIONS,
   createCrudActionPlans,
   hasGraphStorageResource,
-  isCrudObject
+  isCrudObject,
+  VALID_CRUD_GENERATED_BY
 } from './crudActionPlan.js';
 
 const MESSAGE_ATTRIBUTES = ['userId', 'correlationId'];
@@ -13,24 +14,44 @@ export const dynamicCrudFlowSchemaPaths = CRUD_ACTIONS.map(
     `app/src/schemas/FlowSchemas/generateCode/FlowObjects/${action}.js`
 );
 
-export function emitDynamicCrudFlowSchemas({ objects, flows = [], serviceTag }) {
+export function emitDynamicCrudFlowSchemas({
+  objects,
+  flows = [],
+  serviceTag,
+  logger
+}) {
   if (!Array.isArray(objects) || !Array.isArray(flows)) {
     throw new TypeError('objects and flows must be arrays');
   }
-  if (!objects.some(isCrudObject)) return [];
+  if (!objects.some(isCrudObject)) {
+    if (objects.length > 0) {
+      const summary = objects.map((obj) => ({
+        objectType: obj?.objectType ?? '(undefined)',
+        generatedBy: obj?.generatedBy ?? '(missing)'
+      }));
+      logger?.warn?.(
+        `[WARN] [CRUD FlowSchemas] Skipped FlowObjects FlowSchemas generation: No valid CRUD ObjectSchema found. ` +
+        `Checked ${objects.length} object(s): ${JSON.stringify(summary)}. ` +
+        `Expected "generatedBy" to be one of: ${Array.from(VALID_CRUD_GENERATED_BY).join(', ')}`
+      );
+    }
+    return [];
+  }
 
   const plans = createCrudActionPlans(objects);
+  const primaryObject = objects.find(isCrudObject);
+  const initiateBy = primaryObject?.generatedBy || 'user';
 
   return CRUD_ACTIONS.map((action, index) => ({
     path: dynamicCrudFlowSchemaPaths[index],
     content: renderDynamicCrudFlowSchema(
       action,
-      _createDynamicFlow(action, plans[action], serviceTag)
+      _createDynamicFlow(action, plans[action], serviceTag, initiateBy)
     )
   }));
 }
 
-function _createDynamicFlow(action, plan, serviceTag = '') {
+function _createDynamicFlow(action, plan, serviceTag = '', initiateBy = 'user') {
   const flowSteps = [
     {
       stepName: 'Start',
@@ -103,7 +124,7 @@ function _createDynamicFlow(action, plan, serviceTag = '') {
 
   return {
     flowTag: action,
-    initiateBy: 'system',
+    initiateBy,
     handleObj: 'one',
     statusType: 'none',
     event: plan.outputTopic ? ['ownTopic'] : ['lambdaSyncInv', 'lambdaSyncApi'],

package/src/emit/crud/generateCrudApplicationArtifacts.js

@@ -9,10 +9,11 @@ import {
 
 export async function generateCrudApplicationArtifacts(rootPath, options = {}) {
   const project = compileProject({ ...options, rootPath });
-  const schemas = await loadLocalSchemaArrays(project);
+  const schemas = await loadLocalSchemaArrays(project, options);
   const artifacts = await emitCrudApplicationArtifacts({
     ...schemas,
-    serviceTag: project.serviceTag
+    serviceTag: project.serviceTag,
+    logger: options.logger
   });
   const files = await commitArtifacts(
     buildGenerationPlan(project, artifacts, {

package/src/emit/crud/generateDynamicCrudFlowSchemas.js

@@ -9,12 +9,13 @@ import { loadLocalSchemaArrays } from './loadLocalSchemaArrays.js';
 
 export async function generateDynamicCrudFlowSchemas(rootPath, options = {}) {
   const project = compileProject({ ...options, rootPath });
-  const schemaInputs = await loadLocalSchemaArrays(project);
+  const schemaInputs = await loadLocalSchemaArrays(project, options);
   const plan = buildGenerationPlan(
     project,
     emitDynamicCrudFlowSchemas({
       ...schemaInputs,
-      serviceTag: project.serviceTag
+      serviceTag: project.serviceTag,
+      logger: options.logger
     }),
     {
       managedPaths: dynamicCrudFlowSchemaPaths,

package/src/emit/crud/loadLocalSchemaArrays.js

@@ -1,8 +1,8 @@
 import { loadLocalSchemaDirectory } from '../../compile/loadSchemas.js';
 
-export async function loadLocalSchemaArrays(project) {
+export async function loadLocalSchemaArrays(project, options = {}) {
   return {
-    objects: await loadLocalSchemaDirectory(project, 'ObjectSchemas'),
-    flows: await loadLocalSchemaDirectory(project, 'FlowSchemas')
+    objects: await loadLocalSchemaDirectory(project, 'ObjectSchemas', options),
+    flows: await loadLocalSchemaDirectory(project, 'FlowSchemas', options)
   };
 }

package/src/emit/crud/templates/CreateComplete_Main.ejs

@@ -52,7 +52,7 @@ export default async function CreateComplete(
   //(</additionalParams>)
 ) {
   try {
-    _izContext.logger.debug('[CreateComplete] started', {
+    _izContext.logger.debug(`[${process.env.iz_serviceTag}:CreateComplete] started`,  {
       requestParams
     });
     const {

package/src/emit/crud/templates/CreateEndpoint_Main.ejs

@@ -65,7 +65,7 @@ export default async function <%- flowTag %>(
   //(</additionalParams>)
 ) {
   try {
-    _izContext.logger.debug('[<%- flowTag %>] createMain:', {
+    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] createMain:`,  {
       requestParams,
       callingFlowConfig
     });
@@ -78,16 +78,42 @@ export default async function <%- flowTag %>(
       _izContext,
       objType
     );
-    _izContext.logger.debug('objectSchema', objectSchema);
-
-    // ── Resolve userId / targetId ─────────────────────────────────────────────
-    let userId, targetId;
-    if (objectSchema.generatedBy === 'userGenerated') {
-      userId = _izContext.correlationIds.get(coreConsts.BASE_USER_ID);
-      targetId = _izContext.correlationIds.get(coreConsts.TARGET_ID);
-      if (!userId) errorsFound.push('Not have userId');
-      if (objectSchema.hasOwnProperty('belongTo') && !targetId)
-        errorsFound.push('not have targetId');
+    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] objectSchema:`, objectSchema);
+
+    // ── Resolve submittedByUserId / targetIdentifiers ─────────────────────────
+    let submittedByUserId, targetIdentifiers;
+    if (
+      objectSchema.generatedBy === 'user' ||
+      objectSchema.generatedBy === 'systemWithUser'
+    ) {
+      submittedByUserId =
+        requestParams.submittedByUserId ||
+        _izContext.correlationIds.get(coreConsts.SUBMITTED_BY_USER_ID);
+
+      targetIdentifiers = requestParams.targetIdentifiers;
+
+      if (!targetIdentifiers && objectSchema.belongTo?.objectType === 'user' && submittedByUserId) {
+        targetIdentifiers = { submittedByUserId };
+      }
+
+      if (!submittedByUserId) errorsFound.push('Not have submittedByUserId');
+      if (objectSchema.hasOwnProperty('belongTo') && !targetIdentifiers)
+        errorsFound.push('not have targetIdentifiers');
+
+      requestParams.submittedByUserId = submittedByUserId;
+      if (targetIdentifiers) {
+        if (!targetIdentifiers.submittedByUserId && submittedByUserId) {
+          targetIdentifiers.submittedByUserId = submittedByUserId;
+        }
+        requestParams.targetIdentifiers = targetIdentifiers;
+      }
+
+      _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] Identity & Target Context Resolved:`,  {
+        submittedByUserId: requestParams.submittedByUserId,
+        targetIdentifiers: requestParams.targetIdentifiers,
+        belongTo: objectSchema.belongTo,
+        generatedBy: objectSchema.generatedBy
+      });
     } else if (objectSchema.generatedBy === 'searchResultGenerated') {
       throw new NoRetryError(
         'error searchResultGenerated should not happen here'
@@ -103,14 +129,14 @@ export default async function <%- flowTag %>(
         _izContext,
         objectSchema
       );
-    _izContext.logger.debug('objectSchemas', objectSchemas);
+    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] objectSchemas:`, objectSchemas);
 
     // ── Build createDataDetails ───────────────────────────────────────────────
     const createDataDetails = await createDataDetailsLib(
       _izContext,
       objectSchemas
     );
-    _izContext.logger.debug('createDataDetails:', createDataDetails);
+    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] createDataDetails:`, createDataDetails);
 
     if (requestParams.relationships?.length > 0) {
       //(<beforeValidateRelationships>)
@@ -124,9 +150,35 @@ export default async function <%- flowTag %>(
         requestParams.relationships
       ))
     );
-    _izContext.logger.debug('errorsFound', errorsFound);
+    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] errorsFound:`, errorsFound);
+
+    // ── Resolve fromRequiredOnCreate fields ──────────────────────────────────
+    if (objectSchemas.fieldNames) {
+      if (!requestParams.fieldNames) requestParams.fieldNames = {};
+      for (const [fieldName, val] of Object.entries(objectSchemas.fieldNames)) {
+        if (val.fromRequiredOnCreate && requestParams.fieldNames[fieldName] === undefined) {
+          const fromConfig = val.fromRequiredOnCreate;
+          const sourceField = fromConfig.fieldName || fieldName;
+          if (fromConfig.belongToObjType === true && targetIdentifiers) {
+            const targetValue =
+              targetIdentifiers[sourceField] !== undefined
+                ? targetIdentifiers[sourceField]
+                : Object.values(targetIdentifiers)[0];
+            requestParams.fieldNames[fieldName] = targetValue;
+          } else if (fromConfig.relType && requestParams.relationships?.length > 0) {
+            const matchedRel = requestParams.relationships.find(
+              (rel) =>
+                rel.relType?.serviceTag === fromConfig.relType.serviceTag &&
+                rel.relType?.relationshipTag === fromConfig.relType.relationshipTag
+            );
+            if (matchedRel?.targetIdentifiers?.[sourceField] !== undefined) {
+              requestParams.fieldNames[fieldName] = matchedRel.targetIdentifiers[sourceField];
+            }
+          }
+        }
+      }
+    }
 
-    // ── Build field lists ─────────────────────────────────────────────────────
     const listOfRequiredOnCreate = [];
     const listOfOptionalOnCreate = [];
 
@@ -134,6 +186,7 @@ export default async function <%- flowTag %>(
       if (
         val.randomOnCreate === true ||
         val.requiredOnCreate === true ||
+        val.fromRequiredOnCreate ||
         val.hashOnCreate?.length
       ) {
         listOfRequiredOnCreate.push(key);
@@ -177,9 +230,9 @@ export default async function <%- flowTag %>(
       }
     }
 
-    _izContext.logger.debug('requestParams:', requestParams);
+    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] requestParams:`, requestParams);
     errorsFound.push(...errors);
-    _izContext.logger.debug('errorsFound::', errorsFound);
+    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] errorsFound after identifiers:`, errorsFound);
 
     if (errorsFound.length > 0)
       return await <%- flowTag %>LogicalLib(
@@ -216,13 +269,13 @@ export default async function <%- flowTag %>(
         });
       }
       if (errorsFound.length > 0) {
-        _izContext.logger.debug('HaveError::', errorsFound);
+        _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] HaveError:`, errorsFound);
         break;
       }
     }
 
     <%_
-    const rbacObjects = objects.filter(o => (o?.generatedBy === 'userGenerated' || o?.generatedBy === 'systemGenerated') && hasRbacAddOn(o));
+    const rbacObjects = objects.filter(o => isCrudObject(o) && hasRbacAddOn(o));
     const rbacObjectTypes = rbacObjects.map(o => o.objectType);
     const rbacServiceTagMap = {};
     for (const o of rbacObjects) {
@@ -265,12 +318,12 @@ 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,
-          nextFlowStepName: '<%- flowTag %>RbacCallback'
+          nextFlowStepName: '<%- plan?.hasRbacCallback ? `${flowTag}RbacCallback` : `${flowTag}Complete` %>'
         }
       );
 
       _izContext.logger.debug(
-        '[lib:auth:checkRbacPermission] resultPermissionCheck:',
+        `[${process.env.iz_serviceTag}:<%- flowTag %>] checkRbacPermission result:`,
         resultPermissionCheck
       );
 
@@ -436,6 +489,7 @@ export default async function <%- flowTag %>(
       errorsFound
     );
   } catch (err) {
+    _izContext.logger.error(`[${process.env.iz_serviceTag}:<%- flowTag %>] error:`, err);
     throw err;
   }
 }

package/src/emit/crud/templates/CreateLogicalLib.ejs

@@ -77,10 +77,11 @@ export async function <%- flowTag %>LogicalLib(
   phaseResults = {}
 ) {
   try {
-    _izContext.logger.debug('[<%- flowTag %>LogicalLib] started', {
+    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>LogicalLib] started`,  {
       requestParams,
       callingFlowConfig,
-      phaseResults
+      phaseResults,
+      targetIdentifiers: requestParams.targetIdentifiers
     });
 
     //(<beforeCreateMainLogical>)
@@ -93,14 +94,14 @@ export async function <%- flowTag %>LogicalLib(
       _izContext,
       objType
     );
-    _izContext.logger.debug('objectSchema', objectSchema);
+    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>LogicalLib] objectSchema:`, objectSchema);
 
     const objectSchemas =
       uploadUseCase.generateObjectSchemaForCombineFieldNames(
         _izContext,
         objectSchema
       );
-    _izContext.logger.debug('objectSchemas', objectSchemas);
+    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>LogicalLib] objectSchemas:`, objectSchemas);
 
     // ── Parent object ─────────────────────────────────────────────────────────
     let parentObject;
@@ -121,7 +122,7 @@ export async function <%- flowTag %>LogicalLib(
       _izContext,
       objectSchemas
     );
-    _izContext.logger.debug('createDataDetails:', createDataDetails);
+    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>LogicalLib] createDataDetails:`, createDataDetails);
 
     // ── Build objInstanceFull identifiers ─────────────────────────────────────
     const objInstanceFull = { identifiers: {}, fields: {} };
@@ -177,7 +178,7 @@ export async function <%- flowTag %>LogicalLib(
 
         // ── DynamoDB ──────────────────────────────────────────────────────────
         if (createDataDetail.storageType === consts.STORAGE_TYPES.dynamoDB) {
-          _izContext.logger.debug('::::::DynamoDB::::::', {
+          _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>LogicalLib] DynamoDB:`, {
             storageTag,
             objInstanceFull
           });
@@ -256,6 +257,66 @@ export async function <%- flowTag %>LogicalLib(
             );
 
             objInstanceFullForDynamoDb.fields = {};
+
+            // ── Auto-provision owner TargetRole for Root Object with RBAC ─────
+            const hasRbacAddOn = Array.isArray(objectSchema?.addOnDataStructure) &&
+              objectSchema.addOnDataStructure.some((addOn) => addOn?.type === 'rbac');
+            const isRootRbacObject =
+              hasRbacAddOn &&
+              !objectSchema?.belongTo &&
+              objectSchema?.objectType !== 'user' &&
+              objectSchema?.generatedBy !== 'systemNoUser';
+
+            if (isRootRbacObject) {
+              try {
+                const submittedByUserId = requestParams.submittedByUserId || _izContext.correlationIds.get(coreConsts.SUBMITTED_BY_USER_ID);
+                if (submittedByUserId) {
+                  const targetIdentKeys = Object.entries(identifiersForCreateData)
+                    .map(([k, v]) => `${k}#${v}`)
+                    .join('_');
+                  const targetIdentifiersConcat = targetIdentKeys || (identifiersForCreateData[Object.keys(identifiersForCreateData)[0]] ? `${Object.keys(identifiersForCreateData)[0]}#${identifiersForCreateData[Object.keys(identifiersForCreateData)[0]]}` : '');
+
+                  if (targetIdentifiersConcat) {
+                    const roleIdKey = `${targetIdentifiersConcat}_owner`;
+                    _izContext.logger.debug('[CreateLogicalLib] Auto-provisioning owner TargetRole:', {
+                      identifiersConcat: targetIdentifiersConcat,
+                      roleIdKey,
+                      submittedByUserId,
+                      roleName: 'owner'
+                    });
+
+                    await dynamodbSharedLib.putItem(
+                      _izContext,
+                      dynamodbSharedLib.tableName(_izContext, 'TargetRoles'),
+                      {
+                        identifiersConcat: targetIdentifiersConcat,
+                        roleIdKey,
+                        submittedByUserId,
+                        roleName: 'owner',
+                        assignedAt: new Date().toISOString()
+                      }
+                    ).catch(() => {});
+
+                    await dynamodbSharedLib.transactWriteItems(_izContext, [
+                      {
+                        Put: {
+                          TableName: dynamodbSharedLib.tableName(_izContext, 'RoleUsers'),
+                          Item: { roleIdKey, submittedByUserId }
+                        }
+                      },
+                      {
+                        Put: {
+                          TableName: dynamodbSharedLib.tableName(_izContext, 'UserRoles'),
+                          Item: { submittedByUserId, roleIdKey }
+                        }
+                      }
+                    ]).catch(() => {});
+                  }
+                }
+              } catch (roleError) {
+                _izContext.logger.warn('[CreateLogicalLib] Failed to auto-provision owner TargetRole:', { roleError });
+              }
+            }
           }
 
           //(<afterCreateRecordDynamo>)
@@ -267,7 +328,7 @@ export async function <%- flowTag %>LogicalLib(
         ) {
           //(<beforeCreateNode>)
           //(</beforeCreateNode>)
-          _izContext.logger.debug('::::::Graph::::::', {
+          _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>LogicalLib] Graph:`, {
             storageTag,
             objInstanceFull
           });
@@ -435,6 +496,7 @@ export async function <%- flowTag %>LogicalLib(
           objType,
           objInstanceFull: objInstanceFullForGraph,
           relationships: requestParams.relationships || [],
+          targetIdentifiers: requestParams.targetIdentifiers,
           status: 'complete',
           errorsFound
         };
@@ -444,7 +506,7 @@ export async function <%- flowTag %>LogicalLib(
 
     // ── Handle errors ─────────────────────────────────────────────────────────
     if (errorsFound.length > 0) {
-      _izContext.logger.debug('Case have errorsFound:::', errorsFound);
+      _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>LogicalLib] errorsFound:`, errorsFound);
 
       await asyncFlowSharedLib.clearAllAwaitingSteps(
         _izContext,
@@ -479,6 +541,7 @@ export async function <%- flowTag %>LogicalLib(
         objType,
         objInstanceFull,
         relationships: requestParams.relationships || [],
+        targetIdentifiers: requestParams.targetIdentifiers,
         status: 'error',
         errorsFound
       };
@@ -529,10 +592,12 @@ export async function <%- flowTag %>LogicalLib(
         fields: objInstanceFullForDynamoDb.fields
       },
       relationships: requestParams.relationships || [],
+      targetIdentifiers: requestParams.targetIdentifiers,
       status: 'complete',
       errorsFound
     };
   } catch (err) {
+    _izContext.logger.error(`[${process.env.iz_serviceTag}:<%- flowTag %>LogicalLib] error:`, err);
     throw err;
   }
 }

package/src/emit/crud/templates/DeleteComplete_Main.ejs

@@ -52,7 +52,7 @@ export default async function DeleteComplete(
   //(</additionalParams>)
 ) {
   try {
-    _izContext.logger.debug('[DeleteComplete] started', {
+    _izContext.logger.debug(`[${process.env.iz_serviceTag}:DeleteComplete] started`,  {
       requestParams
     });
     const {