@izara_project/izara-core-generate-service-code 1.0.86 → 1.0.88

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

@@ -102,27 +102,27 @@ export async function resolveSchemaAndIdentity(_izContext, requestParams, errors
         targetIdentifiers.submittedByUserId = submittedByUserId;
       }
 
-      if (Array.isArray(objectSchema.identifiers)) {
-        for (const identifier of objectSchema.identifiers) {
-          if (identifier.fieldName) {
-            if (targetIdentifiers[identifier.fieldName] === undefined) {
-              targetIdentifiers[identifier.fieldName] = null;
-            }
-          } else if (Array.isArray(identifier.fieldNames)) {
-            for (const fn of identifier.fieldNames) {
-              if (targetIdentifiers[fn] === undefined) {
-                targetIdentifiers[fn] = null;
-              }
-            }
-          } else if (identifier.name) {
-            if (targetIdentifiers[identifier.name] === undefined) {
-              targetIdentifiers[identifier.name] = null;
-            }
-          }
-        }
-      }
-
-      requestParams.targetIdentifiers = targetIdentifiers;
+      // if (Array.isArray(objectSchema.identifiers)) {
+      //   for (const identifier of objectSchema.identifiers) {
+      //     if (identifier.fieldName) {
+      //       if (targetIdentifiers[identifier.fieldName] === undefined) {
+      //         targetIdentifiers[identifier.fieldName] = null;
+      //       }
+      //     } else if (Array.isArray(identifier.fieldNames)) {
+      //       for (const fn of identifier.fieldNames) {
+      //         if (targetIdentifiers[fn] === undefined) {
+      //           targetIdentifiers[fn] = null;
+      //         }
+      //       }
+      //     } else if (identifier.name) {
+      //       if (targetIdentifiers[identifier.name] === undefined) {
+      //         targetIdentifiers[identifier.name] = null;
+      //       }
+      //     }
+      //   }
+      // }
+
+      // requestParams.targetIdentifiers = targetIdentifiers;
     }
 
     _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] Identity & Target Context Resolved:`, {
@@ -136,7 +136,7 @@ export async function resolveSchemaAndIdentity(_izContext, requestParams, errors
   }
 
   requestParams.submittedByUserId = submittedByUserId;
-  return { objType, objectSchema };
+  return { objType, objectSchema, targetIdentifiers };
 }
 
 /**
@@ -385,21 +385,51 @@ export async function autoProvisionOwnerTargetRole(_izContext, { node, submitted
     }
 
     const identifiers = node.objInstanceFull.identifiers;
-    const targetIdentKeys = Object.entries(identifiers)
-      .filter(([k]) => k !== 'submittedByUserId')
-      .map(([k, v]) => `${k}#${v}`)
-      .join('|');
-
-    const targetIdentifiersConcat =
-      targetIdentKeys ||
-      (identifiers[Object.keys(identifiers)[0]]
-        ? `${Object.keys(identifiers)[0]}#${identifiers[Object.keys(identifiers)[0]]}`
-        : '');
+    const sortedKeys = Object.keys(identifiers)
+      .filter(
+        (k) =>
+          k !== 'submittedByUserId' &&
+          k !== 'identifierConcat' &&
+          k !== 'identifiersConcat'
+      )
+      .sort();
+    const parts = [];
+    for (const key of sortedKeys) {
+      const value = identifiers[key];
+      if (value !== undefined && value !== null) {
+        parts.push(`${key}#${value}`);
+      }
+    }
+    const targetIdentifiersConcat = parts.join('|');
 
     if (!targetIdentifiersConcat) {
       return;
     }
 
+    const targetPlanTier =
+      node?.objInstanceFull?.planTier ||
+      node?.objInstanceFull?.targetIdentifiers?.planTier ||
+      'tier-free';
+    let planTierName = 'Free Plan';
+    if (targetPlanTier === 'tier-pro') {
+      planTierName = 'Professional Plan';
+    } else if (targetPlanTier === 'tier-enterprise') {
+      planTierName = 'Enterprise Plan';
+    }
+
+    await dynamodbSharedLib.putItem(
+      _izContext,
+      dynamodbSharedLib.tableName(_izContext, 'TargetRoles'),
+      {
+        identifiersConcat: targetIdentifiersConcat,
+        roleIdKey: targetPlanTier,
+        roleType: 'plan_tier',
+        roleName: planTierName,
+        submittedByUserId,
+        createdAt: new Date().toISOString()
+      }
+    );
+
     const roleIdKey = `${targetIdentifiersConcat}_owner`;
     _izContext.logger.debug(
       '[CreateNodeCallback] Auto-provisioning owner TargetRole:',
@@ -417,8 +447,9 @@ export async function autoProvisionOwnerTargetRole(_izContext, { node, submitted
       {
         identifiersConcat: targetIdentifiersConcat,
         roleIdKey,
+        roleType: 'tenant_role',
+        roleName: 'Owner',
         submittedByUserId,
-        roleName: 'owner',
         assignedAt: new Date().toISOString()
       }
     );
@@ -816,16 +847,49 @@ export async function autoProvisionOwnerTargetRoleForDynamoOnly(
       _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]]}`
-          : '');
+      const sortedKeys = Object.keys(identifiersForCreateData)
+        .filter(
+          (k) =>
+            k !== 'submittedByUserId' &&
+            k !== 'identifierConcat' &&
+            k !== 'identifiersConcat'
+        )
+        .sort();
+      const parts = [];
+      for (const key of sortedKeys) {
+        const value = identifiersForCreateData[key];
+        if (value !== undefined && value !== null) {
+          parts.push(`${key}#${value}`);
+        }
+      }
+      const targetIdentifiersConcat = parts.join('|');
 
       if (targetIdentifiersConcat) {
+        const targetPlanTier =
+          actionData?.planTier ||
+          requestParams?.planTier ||
+          requestParams?.passBackProperties?.planTier ||
+          'tier-free';
+        let planTierName = 'Free Plan';
+        if (targetPlanTier === 'tier-pro') {
+          planTierName = 'Professional Plan';
+        } else if (targetPlanTier === 'tier-enterprise') {
+          planTierName = 'Enterprise Plan';
+        }
+
+        await dynamodbSharedLib.putItem(
+          _izContext,
+          dynamodbSharedLib.tableName(_izContext, 'TargetRoles'),
+          {
+            identifiersConcat: targetIdentifiersConcat,
+            roleIdKey: targetPlanTier,
+            roleType: 'plan_tier',
+            roleName: planTierName,
+            submittedByUserId,
+            createdAt: new Date().toISOString()
+          }
+        );
+
         const roleIdKey = `${targetIdentifiersConcat}_owner`;
         _izContext.logger.debug(
           '[<%- flowTag %>LogicalLib] Auto-provisioning owner TargetRole for DynamoDB-only:',
@@ -843,8 +907,9 @@ export async function autoProvisionOwnerTargetRoleForDynamoOnly(
           {
             identifiersConcat: targetIdentifiersConcat,
             roleIdKey,
+            roleType: 'tenant_role',
+            roleName: 'Owner',
             submittedByUserId,
-            roleName: 'owner',
             assignedAt: new Date().toISOString()
           }
         );
@@ -1279,6 +1344,7 @@ export async function <%- flowTag %>LogicalLib(
               }
             );
 
+            const fieldsForHook = { ...objInstanceFullForDynamoDb.fields };
             objInstanceFullForDynamoDb.fields = {};
 
             // Auto-provision owner TargetRole for DynamoDB-only
@@ -1287,6 +1353,101 @@ export async function <%- flowTag %>LogicalLib(
               identifiersForCreateData,
               requestParams
             });
+
+            <%_ if (plan?.hasAfterHookSync) { _%>
+            // ── Synchronous After Hooks ──
+            <%_ plan.afterHooks.filter(h => h?.generatedCodeConfig?.invocationType === 'lambdaSyncInv').forEach(hook => { _%>
+            <%_ if (hook.objType?.objectType) { _%>
+            if (objType.objectType === '<%= hook.objType.objectType %>') {
+            <%_ } _%>
+            try {
+              const hookResult = await lambda.invokeSync(
+                _izContext,
+                await lambdaSharedLib.lambdaFunctionName(
+                  _izContext,
+                  '<%= hook.flowTag %>'
+                ),
+                {
+                  requestParams: {
+                    objType,
+                    objInstanceFull: {
+                      identifiers: identifiersForCreateData,
+                      fields: fieldsForHook
+                    },
+                    relationships: requestParams.relationships || [],
+                    targetIdentifiers: requestParams.targetIdentifiers,
+                    submittedByUserId: requestParams.submittedByUserId
+                  },
+                  callingFlowConfig
+                }
+              );
+              if (hookResult?.errorsFound?.length > 0 || hookResult?.status === 'error') {
+                errorsFound.push(...(hookResult.errorsFound || ['Hook <%= hook.flowTag %> failed']));
+              }
+            } catch (hookErr) {
+              _izContext.logger.error('[<%- flowTag %>LogicalLib] Sync hook <%= hook.flowTag %> error:', hookErr);
+              errorsFound.push(hookErr.message || 'Hook <%= hook.flowTag %> failed');
+            }
+            <%_ if (hook.objType?.objectType) { _%>
+            }
+            <%_ } _%>
+            <%_ }) _%>
+            <%_ } _%>
+
+            <%_ if (plan?.hasAfterHookAsync) { _%>
+            // ── Asynchronous After Hooks ──
+            <%_ plan.afterHooks.filter(h => h?.generatedCodeConfig?.invocationType === 'ownTopic').forEach(hook => { _%>
+            <%_ if (hook.objType?.objectType) { _%>
+            if (objType.objectType === '<%= hook.objType.objectType %>') {
+            <%_ } _%>
+            const hookMsg_<%= hook.flowTag %> = callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
+              {
+                objType,
+                objInstanceFull: {
+                  identifiers: identifiersForCreateData,
+                  fields: fieldsForHook
+                },
+                relationships: requestParams.relationships || [],
+                targetIdentifiers: requestParams.targetIdentifiers,
+                submittedByUserId: requestParams.submittedByUserId
+              },
+              callingFlowSharedLib.addParentCallingFlowConfig(
+                callingFlowConfig,
+                callingFlowSharedLib.createCallingFlowConfig(
+                  await lambdaSharedLib.lambdaFunctionName(
+                    _izContext,
+                    '<%- flowTag %>AfterHookCallbackHdrSqs'
+                  ),
+                  {
+                    actionData: {
+                      objType,
+                      objInstanceFull: {
+                        identifiers: identifiersForCreateData,
+                        fields: fieldsForHook
+                      },
+                      relationships: requestParams.relationships || [],
+                      targetIdentifiers: requestParams.targetIdentifiers,
+                      status: 'complete',
+                      errorsFound
+                    }
+                  }
+                )
+              )
+            );
+
+            await sns.publishAsync(_izContext, {
+              TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
+                _izContext,
+                '<%= hook.flowTag %>_In'
+              ),
+              Message: JSON.stringify(hookMsg_<%= hook.flowTag %>),
+              MessageAttributes: sns.createStringMessageAttributes(_izContext, {})
+            });
+            <%_ if (hook.objType?.objectType) { _%>
+            }
+            <%_ } _%>
+            <%_ }) _%>
+            <%_ } _%>
           }
 
           //(<afterCreateRecordDynamo>)
@@ -1440,11 +1601,13 @@ export async function <%- flowTag %>LogicalLib(
 
     // 7. Handle DynamoDB-only Complete Path
     if (allAwaitingStepsId.length === 0 && listOfObjectForCreates.length === 0) {
+      <%_ if (!plan?.hasAfterHookAsync) { _%>
       await handleDynamoDbOnlyComplete(_izContext, {
         objType,
         objInstanceFullForDynamoDb,
         callingFlowConfig
       });
+      <%_ } _%>
     }
 
     return {

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

@@ -171,6 +171,43 @@ export default async function CreateNodeCallbackMain(
           node,
           submittedByUserId
         });
+
+        <%_ if (plan?.hasAfterHookSync) { _%>
+        // ── Synchronous After Hooks ──
+        <%_ plan.afterHooks.filter(h => h?.generatedCodeConfig?.invocationType === 'lambdaSyncInv').forEach(hook => { _%>
+        <%_ if (hook.objType?.objectType) { _%>
+        if (returnValue.requestParams?.objType?.objectType === '<%= hook.objType.objectType %>') {
+        <%_ } _%>
+        try {
+          const hookResult = await lambda.invokeSync(
+            _izContext,
+            await lambdaSharedLib.lambdaFunctionName(
+              _izContext,
+              '<%= hook.flowTag %>'
+            ),
+            {
+              requestParams: {
+                objType: returnValue.requestParams.objType,
+                objInstanceFull: node.objInstanceFull,
+                relationships: node.relationships || [],
+                targetIdentifiers: requestParams.targetIdentifiers,
+                submittedByUserId
+              },
+              callingFlowConfig
+            }
+          );
+          if (hookResult?.errorsFound?.length > 0 || hookResult?.status === 'error') {
+            errorsFound.push(...(hookResult.errorsFound || ['Hook <%= hook.flowTag %> failed']));
+          }
+        } catch (hookErr) {
+          _izContext.logger.error('[CreateNodeCallback] Sync hook <%= hook.flowTag %> error:', hookErr);
+          errorsFound.push(hookErr.message || 'Hook <%= hook.flowTag %> failed');
+        }
+        <%_ if (hook.objType?.objectType) { _%>
+        }
+        <%_ } _%>
+        <%_ }) _%>
+        <%_ } _%>
       }
 
       const callingFlowConfig =
@@ -198,6 +235,48 @@ export default async function CreateNodeCallbackMain(
         _izContext
       );
 
+      <%_ if (plan?.hasAfterHookAsync) { _%>
+      // ── Asynchronous After Hooks ──
+      <%_ plan.afterHooks.filter(h => h?.generatedCodeConfig?.invocationType === 'ownTopic').forEach(hook => { _%>
+      <%_ if (hook.objType?.objectType) { _%>
+      if (returnValue.requestParams?.objType?.objectType === '<%= hook.objType.objectType %>') {
+      <%_ } _%>
+      const hookMsg_<%= hook.flowTag %> = callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
+        {
+          objType: returnValue.requestParams.objType,
+          objInstanceFull: node.objInstanceFull,
+          relationships: node.relationships || [],
+          targetIdentifiers: requestParams.targetIdentifiers,
+          submittedByUserId
+        },
+        callingFlowSharedLib.addParentCallingFlowConfig(
+          callingFlowConfig,
+          callingFlowSharedLib.createCallingFlowConfig(
+            await lambdaSharedLib.lambdaFunctionName(
+              _izContext,
+              'CreateAfterHookCallbackHdrSqs'
+            ),
+            {
+              quotaKeys,
+              actionData
+            }
+          )
+        )
+      );
+
+      await sns.publishAsync(_izContext, {
+        TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
+          _izContext,
+          '<%= hook.flowTag %>_In'
+        ),
+        Message: JSON.stringify(hookMsg_<%= hook.flowTag %>),
+        MessageAttributes: sns.createStringMessageAttributes(_izContext, {})
+      });
+      <%_ if (hook.objType?.objectType) { _%>
+      }
+      <%_ } _%>
+      <%_ }) _%>
+      <%_ } else { _%>
       await forwardToQuotaConfirmation(_izContext, {
         status,
         errorsFound,
@@ -205,6 +284,7 @@ export default async function CreateNodeCallbackMain(
         actionData,
         callingFlowConfig
       });
+      <%_ } _%>
     }
 
     await asyncFlowSharedLib.removeAwaitingMultipleStep(

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

@@ -0,0 +1,99 @@
+/*
+Copyright (C) 2026 Sven Mason <http://izara.io>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import {
+  <%- flowTag %>LogicalLib,
+  handleDeleteError
+} from './<%- upperCaseFlowTag %>LogicalLib.js';
+
+//(<optionalRequire>)
+//(</optionalRequire>)
+
+/**
+ * Handles callback after async BeforeHook completion
+ * @param {Object} _izContext - Izara context object
+ * @param {Object} requestParams - Callback request parameters
+ * @param {Object} passBackProperties - Pass-back properties
+ * @returns {Promise<Object>} Result object
+ */
+export default async function <%- upperCaseFlowTag %>BeforeHookCallbackMain(
+  _izContext,
+  requestParams,
+  passBackProperties
+  //(<additionalParams>)
+  //(</additionalParams>)
+) {
+  try {
+    _izContext.logger.debug('[<%- upperCaseFlowTag %>BeforeHookCallback] started', {
+      requestParams,
+      passBackProperties
+    });
+
+    const {
+      status,
+      errorsFound = [],
+      returnValue,
+      parentFlowId
+    } = requestParams;
+
+    const mergedErrors = Array.isArray(errorsFound) ? [...errorsFound] : [];
+    if (status === 'error' && mergedErrors.length === 0) {
+      mergedErrors.push('BeforeHook execution reported error');
+    }
+
+    const callingFlowConfig =
+      passBackProperties?.callingFlowConfig ||
+      requestParams?.passBackProperties?.callingFlowConfig ||
+      {};
+
+    const originalRequestParams =
+      passBackProperties?.originalRequestParams ||
+      requestParams?.passBackProperties?.originalRequestParams ||
+      passBackProperties?.requestParams ||
+      passBackProperties;
+
+    if (mergedErrors.length > 0) {
+      _izContext.logger.warn(
+        '[<%- upperCaseFlowTag %>BeforeHookCallback] BeforeHook reported errors:',
+        mergedErrors
+      );
+      return await handleDeleteError(_izContext, {
+        objType: originalRequestParams?.objType,
+        identifiers: originalRequestParams?.identifiers || {},
+        targetIdentifiers: originalRequestParams?.targetIdentifiers,
+        callingFlowConfig,
+        errorsFound: mergedErrors
+      });
+    }
+
+    if (returnValue?.identifiers && originalRequestParams?.identifiers) {
+      Object.assign(originalRequestParams.identifiers, returnValue.identifiers);
+    }
+
+    //(<beforeLogicalExecution>)
+    //(</beforeLogicalExecution>)
+
+    return await <%- flowTag %>LogicalLib(
+      _izContext,
+      originalRequestParams,
+      callingFlowConfig
+    );
+  } catch (error) {
+    _izContext.logger.error('[<%- upperCaseFlowTag %>BeforeHookCallback] error:', error);
+    throw error;
+  }
+}