@izara_project/izara-core-generate-service-code 1.0.78 → 1.0.80

package/src/emit/systemText/emitSystemTextSchemas.js

@@ -0,0 +1,246 @@
+import { readFile } from 'node:fs/promises';
+import ejsLib from 'ejs';
+import { rbacFlowTag } from '../rbac/rbacFlowTag.js';
+
+const TEMPLATE_URL = new URL('./templates/', import.meta.url);
+const SYSTEM_TEXT_SCHEMA_PATH =
+  'app/src/schemas/SystemTextSchemas/generatedCode/SystemTextSchemas.js';
+
+const CRUD_ACTIONS = ['Create', 'Update', 'Delete', 'Get'];
+const RELATIONSHIP_ACTIONS = [
+  'CreateRelationship',
+  'UpdateRelationship',
+  'DeleteRelationship',
+  'GetRelationship',
+  'ChangeRelationship',
+  'MoveRelationship'
+];
+const RBAC_SHARED_FLOW_TAGS = [
+  'CreateTargetRole',
+  'ListTargetRole',
+  'DeleteTargetRole',
+  'CreateRolePermissions',
+  'ListRolePermissions',
+  'DeleteRolePermissions',
+  'CreateUserRole',
+  'ListUserInRoles',
+  'DeleteUserFromRole'
+];
+
+export function systemTextSchemaManagedPaths() {
+  return [SYSTEM_TEXT_SCHEMA_PATH];
+}
+
+/**
+ * Emits SystemTextSchemas.js artifact based on objects, relationships, flows, and notifications
+ *
+ * @param {Object} params
+ * @param {Object} params.project
+ * @param {Array} [params.objects=[]]
+ * @param {Array} [params.relationships=[]]
+ * @param {Array} [params.flows=[]]
+ * @param {Array} [params.notifications=[]]
+ * @returns {Promise<Array<{path: string, content: string}>>}
+ */
+export async function emitSystemTextSchemas({
+  project = {},
+  objects = [],
+  relationships = [],
+  flows = [],
+  notifications = []
+} = {}) {
+  const safeObjects = Array.isArray(objects) ? objects : [];
+  const safeRelationships = Array.isArray(relationships) ? relationships : [];
+  const safeFlows = Array.isArray(flows) ? flows : [];
+  const safeNotifications = Array.isArray(notifications) ? notifications : [];
+
+  if (
+    safeObjects.length === 0 &&
+    safeRelationships.length === 0 &&
+    safeFlows.length === 0 &&
+    safeNotifications.length === 0
+  ) {
+    return [];
+  }
+
+  const serviceTag = project?.serviceTag || '';
+  const datas = [];
+
+  // 1. Process Objects
+  for (const object of safeObjects) {
+    const objectType = object?.objectType;
+    if (!objectType) {
+      continue;
+    }
+    const objServiceTag = object?.serviceTag || serviceTag;
+    const fieldNames = Object.keys(object?.fieldNames || {});
+
+    if (Array.isArray(object?.addOnDataStructure)) {
+      for (const addOn of object.addOnDataStructure) {
+        if (addOn?.type === 'versionedData' && addOn?.fieldNames) {
+          fieldNames.push(...Object.keys(addOn.fieldNames));
+        }
+      }
+    }
+
+    for (const fieldName of fieldNames) {
+      const nameSpace = `${objectType}_${objServiceTag}_description`;
+      const systemTextTag = `${fieldName}_${objectType}_${objServiceTag}`;
+      const openHook = `//(<${objectType}_${objServiceTag}${fieldName}Hook>)`;
+      const closeHook = `//(</${objectType}_${objServiceTag}${fieldName}Hook>)`;
+      datas.push({
+        nameSpace,
+        systemTextTag,
+        openHook,
+        closeHook
+      });
+    }
+  }
+
+  // 2. Process Notifications
+  for (const notification of safeNotifications) {
+    if (notification?.notificationGrouping && notification?.notificationTag) {
+      const nameSpace = `sysNotification_${notification.notificationGrouping}`;
+      const systemTextTag = notification.notificationTag;
+      const openHook = `//(<${notification.notificationTag}Hook>)`;
+      const closeHook = `//(</${notification.notificationTag}Hook>)`;
+      datas.push({
+        nameSpace,
+        systemTextTag,
+        openHook,
+        closeHook
+      });
+    }
+  }
+
+  // 3. Process Relationships
+  for (const rel of safeRelationships) {
+    let relTag = rel?.relationshipTag;
+    if (!relTag && typeof rel === 'object' && rel !== null) {
+      relTag = Object.keys(rel)[0];
+    }
+    if (!relTag) {
+      continue;
+    }
+    const relData = rel[relTag] || rel;
+    const relServiceTag = relData?.serviceTag || serviceTag;
+
+    if (relData?.fieldNames && Object.keys(relData.fieldNames).length > 0) {
+      for (const fieldName of Object.keys(relData.fieldNames)) {
+        const nameSpace = `${relTag}_${relServiceTag}_description`;
+        const systemTextTag = `${fieldName}_${relTag}_${relServiceTag}`;
+        const openHook = `//(<${relTag}_${relServiceTag}${fieldName}Hook>)`;
+        const closeHook = `//(</${relTag}_${relServiceTag}${fieldName}Hook>)`;
+        datas.push({
+          nameSpace,
+          systemTextTag,
+          openHook,
+          closeHook
+        });
+      }
+    }
+  }
+
+  // 4. Process Flows (Custom flows + Dynamic flows)
+  const flowTags = [];
+  const seenFlowTags = new Set();
+
+  for (const flow of safeFlows) {
+    const tag = flow?.flowTag || flow;
+    if (typeof tag === 'string' && tag.trim() !== '' && !seenFlowTags.has(tag)) {
+      seenFlowTags.add(tag);
+      flowTags.push(tag);
+    }
+  }
+
+  const dynamicFlowTags = [];
+
+  // Dynamic RBAC flows
+  const rbacObjects = safeObjects.filter(_hasRbacAddOn);
+  if (rbacObjects.length > 0) {
+    for (const rbacObj of rbacObjects) {
+      const tag = rbacFlowTag(rbacObj);
+      if (!seenFlowTags.has(tag) && !dynamicFlowTags.includes(tag)) {
+        dynamicFlowTags.push(tag);
+      }
+    }
+    const hasSelfRbac = safeObjects.some(_hasSelfRbacAddOn);
+    if (hasSelfRbac) {
+      for (const tag of RBAC_SHARED_FLOW_TAGS) {
+        if (!seenFlowTags.has(tag) && !dynamicFlowTags.includes(tag)) {
+          dynamicFlowTags.push(tag);
+        }
+      }
+    }
+  }
+
+  // Dynamic CRUD flows
+  const hasCrudObjects = safeObjects.some(
+    (object) =>
+      object?.generatedBy === 'userGenerated' ||
+      object?.generatedBy === 'systemGenerated'
+  );
+  if (hasCrudObjects) {
+    for (const action of CRUD_ACTIONS) {
+      if (!seenFlowTags.has(action) && !dynamicFlowTags.includes(action)) {
+        dynamicFlowTags.push(action);
+      }
+    }
+  }
+
+  // Dynamic Relationship flows
+  if (safeRelationships.length > 0) {
+    for (const action of RELATIONSHIP_ACTIONS) {
+      if (!seenFlowTags.has(action) && !dynamicFlowTags.includes(action)) {
+        dynamicFlowTags.push(action);
+      }
+    }
+  }
+
+  // Sort dynamic flows in descending alphabetical order to match legacy contract
+  dynamicFlowTags.sort((a, b) => b.localeCompare(a));
+
+  for (const tag of dynamicFlowTags) {
+    if (!seenFlowTags.has(tag)) {
+      seenFlowTags.add(tag);
+      flowTags.push(tag);
+    }
+  }
+
+  for (const flowTag of flowTags) {
+    const nameSpace = `${flowTag}_${serviceTag}`;
+    const systemTextTag = `errors_${flowTag}_${serviceTag}`;
+    const openHook = `//(<${flowTag}_${serviceTag}Hook>)`;
+    const closeHook = `//(</${flowTag}_${serviceTag}Hook>)`;
+    datas.push({
+      nameSpace,
+      systemTextTag,
+      openHook,
+      closeHook
+    });
+  }
+
+  const templateContent = await readFile(
+    new URL('SystemTextSchemas.ejs', TEMPLATE_URL),
+    'utf8'
+  );
+  const content = ejsLib.render(templateContent, { datas });
+
+  return [
+    {
+      path: SYSTEM_TEXT_SCHEMA_PATH,
+      content
+    }
+  ];
+}
+
+function _hasSelfRbacAddOn(object) {
+  if (Array.isArray(object?.addOnDataStructure)) {
+    return object.addOnDataStructure.some((addOn) => addOn?.type === 'rbac');
+  }
+  return false;
+}
+
+function _hasRbacAddOn(object) {
+  return _hasSelfRbacAddOn(object);
+}

package/src/emit/systemText/templates/SystemTextSchemas.ejs

@@ -0,0 +1,10 @@
+export default [
+<% datas.forEach((data, index) => { -%>
+  {
+    nameSpace: "<%- data.nameSpace %>",
+    systemTextTag: "<%- data.systemTextTag %>",
+    <%- data.openHook %>
+    <%- data.closeHook %>
+  }<%= index < datas.length - 1 ? ',' : '' %>
+<% }); -%>
+];

package/src/generate.js

@@ -51,6 +51,10 @@ import {
   emitCoreFunctionArtifacts,
   coreFunctionManagedPaths
 } from './emit/coreFunction/emitCoreFunctionArtifacts.js';
+import {
+  emitSystemTextSchemas,
+  systemTextSchemaManagedPaths
+} from './emit/systemText/emitSystemTextSchemas.js';
 
 export async function generate(rootPath, options = {}) {
   const startedAt = Date.now();
@@ -58,10 +62,11 @@ export async function generate(rootPath, options = {}) {
   logger?.info?.(`[INFO] [Generate] STATUS=STARTED | rootPath=${rootPath}`);
   try {
     const project = compileProject({ ...options, rootPath });
-    const [rawObjects, relationships, flows] = await Promise.all([
+    const [rawObjects, relationships, flows, notifications] = await Promise.all([
       loadLocalSchemaDirectory(project, 'ObjectSchemas'),
       loadLocalSchemaDirectory(project, 'RelationshipSchemas'),
-      loadLocalSchemaDirectory(project, 'FlowSchemas')
+      loadLocalSchemaDirectory(project, 'FlowSchemas'),
+      loadLocalSchemaDirectory(project, 'NotificationSchemas')
     ]);
     const schemaBucketName =
       options.schemaBucketName || process.env.iz_serviceSchemaBucketName;
@@ -85,6 +90,7 @@ export async function generate(rootPath, options = {}) {
       objects,
       relationships,
       flows,
+      notifications,
       objectGraphServiceTags,
       relationshipGraphServiceTags
     });
@@ -120,8 +126,25 @@ export async function generate(rootPath, options = {}) {
   }
 }
 
-async function _emitGroups({ project, objects, relationships, flows, objectGraphServiceTags, relationshipGraphServiceTags }) {
-  const [crud, relationship, rbac, system, findData, resource, coreFunction] = await Promise.all([
+async function _emitGroups({
+  project,
+  objects,
+  relationships,
+  flows,
+  notifications,
+  objectGraphServiceTags,
+  relationshipGraphServiceTags
+}) {
+  const [
+    crud,
+    relationship,
+    rbac,
+    system,
+    findData,
+    resource,
+    coreFunction,
+    systemText
+  ] = await Promise.all([
     emitCrudApplicationArtifacts({
       objects,
       flows,
@@ -133,10 +156,26 @@ async function _emitGroups({ project, objects, relationships, flows, objectGraph
       serviceTag: project.serviceTag
     }),
     emitRbacApplicationArtifacts(objects),
-    emitSystemWebSocketArtifacts(flows, { includeRelationshipOwnTopic: true }),
+    emitSystemWebSocketArtifacts(flows, {
+      includeRelationshipOwnTopic: true
+    }),
     emitSystemFindDataArtifacts(objects),
     emitResourceArtifacts({ objects, relationships, flows }),
-    emitCoreFunctionArtifacts({ project, objects, relationships, flows, objectGraphServiceTags, relationshipGraphServiceTags })
+    emitCoreFunctionArtifacts({
+      project,
+      objects,
+      relationships,
+      flows,
+      objectGraphServiceTags,
+      relationshipGraphServiceTags
+    }),
+    emitSystemTextSchemas({
+      project,
+      objects,
+      relationships,
+      flows,
+      notifications
+    })
   ]);
   const custom = await emitCustomFlowApplicationArtifacts(flows, {
     objects
@@ -158,11 +197,14 @@ async function _emitGroups({ project, objects, relationships, flows, objectGraph
 
   let resolvedCoreFunctionManagedPaths = coreFunctionManagedPaths;
   if (typeof coreFunctionManagedPaths === 'function') {
-    resolvedCoreFunctionManagedPaths = coreFunctionManagedPaths(
+    resolvedCoreFunctionManagedPaths = coreFunctionManagedPaths({
+      project,
       objects,
+      relationships,
+      flows,
       objectGraphServiceTags,
       relationshipGraphServiceTags
-    );
+    });
   }
 
   return [
@@ -223,6 +265,11 @@ async function _emitGroups({ project, objects, relationships, flows, objectGraph
       scope: 'core-function',
       managedPaths: resolvedCoreFunctionManagedPaths,
       artifacts: coreFunction
+    },
+    {
+      scope: 'system-text-schemas',
+      managedPaths: systemTextSchemaManagedPaths(),
+      artifacts: systemText
     }
   ];
 }

package/test/crudApplicationArtifacts.test.js

@@ -22,7 +22,7 @@ test('emits CRUD handlers and function YAML from schema data without reading gen
     serviceTag: 'orders'
   });
 
-  assert.equal(result.files.length, 26);
+  assert.equal(result.files.length, 25);
   assert.ok(result.files.every((file) => !file.path.includes('/Process')));
   assert.match(
     await readFile(
@@ -34,16 +34,15 @@ test('emits CRUD handlers and function YAML from schema data without reading gen
     ),
     /dataFromGraphV2/
   );
-  assert.match(
-    await readFile(
+  const createMain = await readFile(
       join(
         rootPath,
         'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js'
       ),
       'utf8'
-    ),
-    /beforeLogical_order/
-  );
+    );
+  assert.match(createMain, /CreateLogicalLib/);
+  assert.doesNotMatch(createMain, /FlowHook|beforeLogical|codeHookTag/);
   const yaml = await readFile(
     join(rootPath, 'app/sls_yaml/generatedCode/source/flow-objects.yml'),
     'utf8'
@@ -53,14 +52,16 @@ test('emits CRUD handlers and function YAML from schema data without reading gen
   assert.doesNotMatch(yaml, /handler: .*\/Process/);
   assert.match(yaml, /path: \/orders\/order\/get/);
   assert.match(yaml, /GetHdrInv:/);
+  assert.doesNotMatch(yaml, /GetRangeHdrApi:/);
+  assert.match(yaml, /UpdateCompleteHdrSqs:/);
+  assert.match(yaml, /#<#UpdateCompleteHdrSqsFunctionSetting#>/);
   assert.match(yaml, /CreateCompleteHdrSqs:/);
-  assert.match(yaml, /#<#CreateCompleteHdrSqsFunctionSetting#>/);
-  assert.match(yaml, /filterPatterns:[\s\S]*CreateCompleteHdrSqs/);
+  assert.doesNotMatch(yaml, /FlowHook|RbacCallbackAndSendFlowHook/);
   assert.match(
     await readFile(
       join(
         rootPath,
-        'app/src/generatedCode/FlowObjects/Create/source/CreateComplete_Main.js'
+        'app/src/generatedCode/FlowObjects/Update/source/UpdateComplete_Main.js'
       ),
       'utf8'
     ),
@@ -84,7 +85,7 @@ test('emits CRUD handlers and function YAML from schema data without reading gen
       )
     )
   );
-  for (const action of ['Create', 'Update', 'Delete']) {
+  for (const action of ['Update', 'Delete']) {
     execFileSync(
       process.execPath,
       [
@@ -120,10 +121,10 @@ test('preserves function-setting hooks across CRUD regeneration', async () => {
   await generateCrudApplicationArtifacts(rootPath, { serviceTag: 'orders' });
 
   const hookCode =
-    '  #<#CreateCompleteHdrSqsFunctionSetting#>\n  memorySize: 512\n  #<#/CreateCompleteHdrSqsFunctionSetting#>\n';
+    '  #<#UpdateCompleteHdrSqsFunctionSetting#>\n  memorySize: 512\n  #<#/UpdateCompleteHdrSqsFunctionSetting#>\n';
   let yaml = await readFile(yamlPath, 'utf8');
   const withHook = yaml.replace(
-    /  #<#CreateCompleteHdrSqsFunctionSetting#>[\s\S]*?#<#\/CreateCompleteHdrSqsFunctionSetting#>/,
+    /  #<#UpdateCompleteHdrSqsFunctionSetting#>[\s\S]*?#<#\/UpdateCompleteHdrSqsFunctionSetting#>/,
     hookCode.trim()
   );
   assert.notEqual(yaml, withHook, 'hook placeholder must exist in generated YAML');
@@ -134,13 +135,13 @@ test('preserves function-setting hooks across CRUD regeneration', async () => {
   yaml = await readFile(yamlPath, 'utf8');
   assert.match(
     yaml,
-    /#<#CreateCompleteHdrSqsFunctionSetting#>\n  memorySize: 512\n  #<#\/CreateCompleteHdrSqsFunctionSetting#>/
+    /#<#UpdateCompleteHdrSqsFunctionSetting#>\n  memorySize: 512\n  #<#\/UpdateCompleteHdrSqsFunctionSetting#>/
   );
 
   const customFilterHook =
-    '        #<#CreateCompleteHdrSqsFilterPatterns#>\n        filterPatterns:\n          - body: custom\n        #<#/CreateCompleteHdrSqsFilterPatterns#>';
+    '        #<#UpdateCompleteHdrSqsFilterPatterns#>\n        filterPatterns:\n          - body: custom\n        #<#/UpdateCompleteHdrSqsFilterPatterns#>';
   const withFilterHook = yaml.replace(
-    /        #<#CreateCompleteHdrSqsFilterPatterns#>[\s\S]*?#<#\/CreateCompleteHdrSqsFilterPatterns#>/,
+    /        #<#UpdateCompleteHdrSqsFilterPatterns#>[\s\S]*?#<#\/UpdateCompleteHdrSqsFilterPatterns#>/,
     customFilterHook
   );
   assert.notEqual(
@@ -155,7 +156,7 @@ test('preserves function-setting hooks across CRUD regeneration', async () => {
   yaml = await readFile(yamlPath, 'utf8');
   assert.match(
     yaml,
-    /#<#CreateCompleteHdrSqsFilterPatterns#>\n        filterPatterns:\n          - body: custom\n        #<#\/CreateCompleteHdrSqsFilterPatterns#>/
+    /#<#UpdateCompleteHdrSqsFilterPatterns#>\n        filterPatterns:\n          - body: custom\n        #<#\/UpdateCompleteHdrSqsFilterPatterns#>/
   );
 
   const conflictPath = join(
@@ -172,6 +173,127 @@ test('preserves function-setting hooks across CRUD regeneration', async () => {
   assert.equal(await readFile(yamlPath, 'utf8'), yaml);
 });
 
+test('does not add RBAC handlers to Create', async () => {
+  const rootPath = await createRbacProject();
+  const result = await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+  const createPaths = result.files
+    .map((file) => file.path)
+    .filter((path) => path.includes('/FlowObjects/Create/source/'));
+
+  assert.ok(createPaths.includes(
+    'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js'
+  ));
+  assert.ok(!createPaths.includes(
+    'app/src/generatedCode/FlowObjects/Create/source/CreateComplete_Main.js'
+  ));
+  assert.ok(
+    !createPaths.some((path) => path.includes('CreateRbacCallback'))
+  );
+  assert.doesNotMatch(
+    await readFile(
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Create/source/Create_Main.js'
+      ),
+      'utf8'
+    ),
+    /checkRbacPermission/
+  );
+});
+
+test('emits a single Complete RBAC handler for Update without Graph', async () => {
+  const rootPath = await createRbacProject();
+  const result = await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+  const updatePaths = result.files
+    .map((file) => file.path)
+    .filter((path) => path.includes('/FlowObjects/Update/source/'));
+
+  assert.ok(updatePaths.includes(
+    'app/src/generatedCode/FlowObjects/Update/source/UpdateComplete_Main.js'
+  ));
+  assert.ok(!updatePaths.some((path) => path.includes('UpdateRbacCallback')));
+  assert.match(
+    await readFile(
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Update/source/UpdateComplete_Main.js'
+      ),
+      'utf8'
+    ),
+    /UpdateLogicalLib/
+  );
+});
+
+test('emits RbacCallback and Complete handlers for Update with Graph', async () => {
+  const rootPath = await createRbacProject(false, true);
+  const result = await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+  const updatePaths = result.files
+    .map((file) => file.path)
+    .filter((path) => path.includes('/FlowObjects/Update/source/'));
+
+  assert.ok(updatePaths.includes(
+    'app/src/generatedCode/FlowObjects/Update/source/UpdateRbacCallback_Main.js'
+  ));
+  assert.ok(updatePaths.includes(
+    'app/src/generatedCode/FlowObjects/Update/source/UpdateComplete_Main.js'
+  ));
+  execFileSync(
+    process.execPath,
+    [
+      '--check',
+      join(
+        rootPath,
+        'app/src/generatedCode/FlowObjects/Update/source/UpdateRbacCallback_Main.js'
+      )
+    ],
+    { stdio: 'inherit' }
+  );
+});
+
+test('rejects deprecated FlowHook schemas', async () => {
+  const rootPath = await createRbacProject(true);
+
+  await assert.rejects(
+    generateCrudApplicationArtifacts(rootPath, { serviceTag: 'orders' }),
+    /generatedCodeConfig\.codeHookTag is no longer supported/
+  );
+});
+
+test('emits GetRangeHdrApi when an object defines a sortKey identifier', async () => {
+  const rootPath = await createProject(true);
+  await writeFile(
+    join(rootPath, 'app/src/schemas/ObjectSchemas/Order.js'),
+    "export default { objectType: 'order', generatedBy: 'userGenerated', identifiers: [{ type: 'identifier', fieldName: 'orderId' }, { type: 'sortKey', fieldName: 'createdAt' }], storageResources: { graph: { storageType: 'graph' } } };\n"
+  );
+  const result = await generateCrudApplicationArtifacts(rootPath, {
+    serviceTag: 'orders'
+  });
+
+  assert.equal(result.files.length, 27);
+  const yaml = await readFile(
+    join(rootPath, 'app/sls_yaml/generatedCode/source/flow-objects.yml'),
+    'utf8'
+  );
+  assert.match(yaml, /GetRangeHdrApi:/);
+  assert.match(yaml, /path: \/orders\/order\/getRange/);
+  const getRangeMain = await readFile(
+    join(
+      rootPath,
+      'app/src/generatedCode/FlowObjects/Get/source/GetRange_Main.js'
+    ),
+    'utf8'
+  );
+  assert.match(getRangeMain, /identifierField/);
+  assert.match(getRangeMain, /startKey/);
+  assert.match(getRangeMain, /itemNumber/);
+  assert.match(getRangeMain, /queryResults/);
+});
 
 test('removes managed CRUD artifacts when no applicable object remains', async () => {
   const rootPath = await createProject(true);
@@ -219,12 +341,29 @@ async function createProject(withCrudObject) {
   await writeFile(
     join(schemaRoot, 'ObjectSchemas/Order.js'),
     withCrudObject
-      ? "export default { objectType: 'order', generatedBy: 'userGenerated' };\n"
+      ? "export default { objectType: 'order', generatedBy: 'userGenerated', storageResources: { graph: { storageType: 'graph' } } };\n"
       : "export default { objectType: 'order' };\n"
   );
+  return rootPath;
+}
+
+async function createRbacProject(withHook = false, withGraph = false) {
+  const rootPath = await mkdtemp(
+    join(tmpdir(), 'generate-service-code-v2-crud-rbac-artifacts-')
+  );
+  roots.add(rootPath);
+  const schemaRoot = join(rootPath, 'app/src/schemas');
+  await mkdir(join(schemaRoot, 'ObjectSchemas'), { recursive: true });
+  await mkdir(join(schemaRoot, 'FlowSchemas'), { recursive: true });
   await writeFile(
-    join(schemaRoot, 'FlowSchemas/OrderBeforeLogical.js'),
-    "export default { flowTag: 'orderHook', event: ['ownTopic'], generatedCodeConfig: { generatedCodeTag: 'create', codeHookTag: 'beforeLogical', invocationType: 'ownTopic', objType: { objectType: 'order' } } };\n"
+    join(schemaRoot, 'ObjectSchemas/Order.js'),
+    `export default { objectType: 'order', generatedBy: 'userGenerated', belongTo: { serviceTag: 'UserAccount', objectType: 'user' }${withGraph ? ", storageResources: { graph: { storageType: 'graph' } }" : ''} };\n`
   );
+  if (withHook) {
+    await writeFile(
+      join(schemaRoot, 'FlowSchemas/OrderBeforeLogical.js'),
+      "export default { flowTag: 'orderHook', event: ['ownTopic'], generatedCodeConfig: { generatedCodeTag: 'create', codeHookTag: 'beforeLogical', invocationType: 'ownTopic', objType: { objectType: 'order' } } };\n"
+    );
+  }
   return rootPath;
 }