@omen.foundation/node-microservice-runtime 0.1.103 → 0.1.105

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omen.foundation/node-microservice-runtime",
-  "version": "0.1.103",
+  "version": "0.1.105",
   "description": "Beamable microservice runtime for Node.js/TypeScript services.",
   "type": "module",
   "main": "dist/index.js",

package/scripts/publish-service.mjs

@@ -747,19 +747,39 @@ async function fetchCurrentManifest(apiHost, token, cid, pid) {
   return response.json();
 }
 
-async function discoverStorageObjects(srcDir) {
+async function discoverStorageObjects(srcDir, cwd = process.cwd()) {
   const storageObjects = [];
   try {
-    const srcPath = path.resolve(srcDir || 'src');
+    // Resolve src path relative to current working directory (where publish is run from)
+    const srcPath = path.isAbsolute(srcDir) ? srcDir : path.resolve(cwd, srcDir || 'src');
+    
+    console.log(`[beamo-node] Searching for @StorageObject decorators in: ${srcPath}`);
+    
+    // Check if directory exists
+    try {
+      const stats = await fs.stat(srcPath);
+      if (!stats.isDirectory()) {
+        console.warn(`[beamo-node] Warning: ${srcPath} is not a directory`);
+        return storageObjects;
+      }
+    } catch (error) {
+      console.warn(`[beamo-node] Warning: Directory ${srcPath} does not exist`);
+      return storageObjects;
+    }
+    
     const files = await getAllTypeScriptFiles(srcPath);
     
     if (files.length === 0) {
       console.warn(`[beamo-node] Warning: No TypeScript files found in ${srcPath}`);
+      return storageObjects;
     }
     
+    console.log(`[beamo-node] Scanning ${files.length} TypeScript file(s) for @StorageObject decorators...`);
+    
     for (const file of files) {
       const content = await fs.readFile(file, 'utf-8');
-      // Match @StorageObject('StorageName') pattern
+      // Match @StorageObject('StorageName') pattern - handle both single and double quotes
+      // Also match multiline patterns where decorator might be on a different line
       const storageRegex = /@StorageObject\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
       let match;
       while ((match = storageRegex.exec(content)) !== null) {
@@ -771,16 +791,20 @@ async function discoverStorageObjects(srcDir) {
             checksum: null,
             archived: false,
           });
-          console.log(`[beamo-node] Discovered storage object: ${storageName}`);
+          console.log(`[beamo-node] ✓ Discovered storage object: ${storageName} (from ${path.relative(cwd, file)})`);
         }
       }
     }
     
     if (storageObjects.length === 0) {
-      console.log(`[beamo-node] No @StorageObject decorators found in ${srcPath}`);
+      console.log(`[beamo-node] No @StorageObject decorators found in ${files.length} file(s) in ${srcPath}`);
+      console.log(`[beamo-node] Make sure your storage classes are decorated with @StorageObject('StorageName')`);
     }
   } catch (error) {
     console.warn(`[beamo-node] Error discovering storage objects: ${error instanceof Error ? error.message : String(error)}`);
+    if (error instanceof Error && error.stack) {
+      console.warn(`[beamo-node] Stack: ${error.stack}`);
+    }
     // If we can't discover storage, that's okay - we'll just use existing ones
   }
   return storageObjects;
@@ -887,8 +911,10 @@ async function updateManifest({
         id: reference.id?.Value ?? reference.id,
         storageType: reference.storageType?.Value ?? reference.storageType ?? 'mongov1',
         enabled: reference.enabled?.Value ?? reference.enabled ?? true,
-        checksum: reference.checksum?.Value ?? reference.checksum,
-        archived: reference.archived?.Value ?? reference.archived ?? false,
+        // templateId and archived are optional - only include if present
+        ...(reference.templateId ? { templateId: reference.templateId?.Value ?? reference.templateId } : {}),
+        ...(reference.archived !== undefined ? { archived: reference.archived?.Value ?? reference.archived ?? false } : {}),
+        // Note: checksum is computed by backend, we don't send it
       }))
     : [];
   
@@ -906,20 +932,41 @@ async function updateManifest({
   });
   discoveredStorage.forEach(s => {
     if (!storageMap.has(s.id)) {
-      storageMap.set(s.id, {
-        ...s,
+      // New storage - create ServiceStorageReference matching backend case class:
+      // case class ServiceStorageReference(id: String, storageType: String, enabled: Boolean, templateId: Option[String] = None, archived: Option[Boolean] = None)
+      const newStorage = {
+        id: s.id,
         storageType: 'mongov1', // All discovered storage uses MongoDB
-      });
+        enabled: true,
+        // templateId and archived are optional - only include if explicitly set
+        ...(s.templateId ? { templateId: s.templateId } : {}),
+        ...(s.archived !== undefined ? { archived: s.archived } : {}),
+      };
+      storageMap.set(s.id, newStorage);
+      console.log(`[beamo-node] Adding new storage to manifest: ${s.id} (type: ${newStorage.storageType}, enabled: ${newStorage.enabled})`);
     } else {
-      // Update existing storage to ensure storageType is 'mongov1'
+      // Update existing storage to ensure storageType is 'mongov1' and format is correct
       const existing = storageMap.get(s.id);
-      storageMap.set(s.id, {
-        ...existing,
+      const updatedStorage = {
+        id: existing.id,
         storageType: 'mongov1',
-      });
+        enabled: existing.enabled !== false, // Ensure enabled is true unless explicitly false
+        // Only include optional fields if they have values
+        ...(existing.templateId ? { templateId: existing.templateId } : {}),
+        ...(existing.archived !== undefined ? { archived: existing.archived } : {}),
+      };
+      storageMap.set(s.id, updatedStorage);
+      console.log(`[beamo-node] Updating existing storage in manifest: ${s.id} (type: mongov1, enabled: ${updatedStorage.enabled})`);
     }
   });
-  const storageReferences = Array.from(storageMap.values());
+  // Convert to array and remove any extra fields (like checksum) that backend doesn't expect
+  const storageReferences = Array.from(storageMap.values()).map(s => ({
+    id: s.id,
+    storageType: s.storageType,
+    enabled: s.enabled,
+    ...(s.templateId ? { templateId: s.templateId } : {}),
+    ...(s.archived !== undefined ? { archived: s.archived } : {}),
+  }));
 
   // Extract existing components and dependencies for the service
   const existingServiceRef = serviceReferences.find(
@@ -1027,10 +1074,19 @@ async function updateManifest({
   if (storageReferences.length > 0) {
     console.log(`[beamo-node] Publishing ${storageReferences.length} storage reference(s) in manifest:`);
     storageReferences.forEach(s => {
-      console.log(`[beamo-node]   - ${s.id} (type: ${s.storageType || 'mongov1'}, enabled: ${s.enabled !== false})`);
+      const details = [
+        `id: ${s.id}`,
+        `storageType: ${s.storageType || 'mongov1'}`,
+        `enabled: ${s.enabled !== false}`,
+        ...(s.templateId ? [`templateId: ${s.templateId}`] : []),
+        ...(s.archived !== undefined ? [`archived: ${s.archived}`] : []),
+      ].join(', ');
+      console.log(`[beamo-node]   - ${details}`);
     });
+    console.log(`[beamo-node] Storage references JSON: ${JSON.stringify(storageReferences, null, 2)}`);
   } else {
-    console.warn(`[beamo-node] Warning: No storage references in manifest. Database will not be created automatically.`);
+    console.warn(`[beamo-node] ⚠️  WARNING: No storage references in manifest. Database will NOT be created automatically.`);
+    console.warn(`[beamo-node] Make sure you have @StorageObject('StorageName') decorators in your code.`);
   }
 
   const publishUrl = new URL('/basic/beamo/manifest', apiHost);
@@ -1458,7 +1514,7 @@ async function main() {
     progress.start('Discovering storage objects and components');
     // shortImageId already defined above from verification step
     const existingManifest = await fetchCurrentManifest(apiHost, token, cid, pid);
-    const discoveredStorage = await discoverStorageObjects('src');
+    const discoveredStorage = await discoverStorageObjects('src', process.cwd());
     const discoveredComponents = await discoverFederationComponents('src');
     // Dependencies are ServiceDependencyReference objects with id and storageType
     // storageType should be "mongov1" for MongoDB storage objects (matching C# microservices)