fix relations

Author: tysonrm

src/domain/make-relations.js

@@ -5,12 +5,12 @@
  */
 
 import domainEvents from './domain-events'
-import { importModelCache, importRemoteCache } from './import-remotes'
+import { importModelCache } from './import-remotes'
 
 const { internalCacheRequest, internalCacheResponse, externalCacheRequest } =
   domainEvents
 
-const maxwait = process.env.REMOTE_OBJECT_MAXWAIT || 2000
+const maxwait = process.env.REMOTE_OBJECT_MAXWAIT || 1000
 
 export const relationType = {
   /**
@@ -151,21 +151,32 @@ const updateForeignKeys = {
  * @param {import('./datasource').default} ds
  * @returns
  */
-async function createNewModels (args, fromModel, relation, ds) {
+async function createModels (args, fromModel, relation, ds) {
   if (args.length > 0) {
-    const {
-      UseCaseService,
-      importRemoteCache,
-      default: ModelFactory
-    } = require('.')
-    const service = UseCaseService(relation.modelName.toUpperCase())
+    const { UseCaseService } = require('.')
+    const service = UseCaseService(relation.modelName)
     const newModels = await Promise.all(
       args.map(arg => service.createModel(arg))
     )
     return updateForeignKeys[relation.type](fromModel, newModels, relation, ds)
   }
 }
 
+async function createNewModels (args, rel, datasource) {
+  if (args.length > 0 && rel.type !== 'custom') {
+    // fetch the local ds and create the models
+    const ds = datasource.factory.getDataSource(rel.modelName)
+    return {
+      yes: true,
+      create: async () => await createModels(args, this, rel, ds)
+    }
+  }
+  return {
+    yes: false,
+    create: () => null
+  }
+}
+
 /**
  * Find existing, or create new, remote objects from
  * the distributed cache and store them in the local cache.
@@ -180,14 +191,13 @@ async function createNewModels (args, fromModel, relation, ds) {
 export function requireRemoteObject (model, relation, broker, ...args) {
   const request = internalCacheRequest(relation.modelName)
   const response = internalCacheResponse(relation.modelName)
-
-  console.debug({ fn: requireRemoteObject.name, relation })
-
   const name = (model ? model.getName() : relation.modelName).toUpperCase()
   const id = model ? model.getId() : relation.id
   const eventSource = name
   const eventTarget = model ? relation.modelName.toUpperCase() : null
 
+  console.debug({ fn: requireRemoteObject.name, relation })
+
   const requestData = {
     eventName: request,
     modelName: name,
@@ -251,20 +261,15 @@ export default function makeRelations (relations, datasource, broker) {
           async [relation] (...args) {
             const local = isRelatedModelLocal(relModelName)
             if (!local) await importModelCache(relModelName)
-            // Get existing (or create temp) datasource of related object
-            const createNew = args?.length > 0
 
-            if (createNew && rel.type !== 'custom') {
-              // fetch the local ds and create the models
-              const ds = datasource.factory.getDataSource(rel.modelName)
-              return await createNewModels(args, this, rel, ds)
+            if (local) {
+              const result = createNewModels(args, rel, datasource)
+              if (result.yes) return result.create()
             }
 
-            // if the object is remote, we now have its code
-            const ds = datasource.factory.getDataSource(
-              rel.modelName,
-              require('.').default.getModelSpec(relModelName).domain
-            )
+            // If object is remote, we should have its code by now.
+            // Recreate its datasource, including any customization
+            const ds = datasource.factory.getDataSource(relModelName)
 
             const models = await relationType[rel.type](this, ds, rel, args)
 
@@ -277,7 +282,7 @@ export default function makeRelations (relations, datasource, broker) {
                 ...args
               )
 
-              if (createNew)
+              if (args.length > 0)
                 updateForeignKeys[rel.type](this, event.model, rel, ds)
 
               return await relationType[rel.type](this, ds, rel, args)

src/domain/use-cases/load-models.js

@@ -4,18 +4,18 @@ import { isMainThread } from 'worker_threads'
 import { Writable, Transform } from 'node:stream'
 import Serializer from '../serializer'
 
-function nextModelFn(port, mf) {
+function nextModelFn (port, mf) {
   mf
     .getModelSpecs()
     .filter(spec => spec.ports)
     .map(spec =>
       Object.entries(spec.ports)
         .filter(p => port.consumesEvent === port)
-        .reduce(p => spec.modelName)
+        .reduce(p => spec.modelName, [])
     )[0]
 }
 
-function startWorkflow(model, mf) {
+function startWorkflow (model, mf) {
   const history = model.getPortFlow()
   const ports = model.getPorts()
 
@@ -54,27 +54,27 @@ export default function ({ modelName, repository, broker, models }) {
     const rehydrate = new Transform({
       objectMode: true,
 
-      transform(chunk, _endcoding, next) {
+      transform (chunk, _endcoding, next) {
         const model = models.loadModel(broker, repository, chunk, modelName)
         repository.saveSync(model.getId(), model)
         this.push(model)
         next()
-      },
+      }
     })
 
     const resumeWorkflow = new Writable({
       objectMode: true,
 
-      write(chunk, _encoding, next) {
-        startWorkflow(chunk)
+      write (chunk, _encoding, next) {
+        startWorkflow(chunk, models)
         next()
         return true
       },
 
-      end(chunk, _encoding, done) {
-        startWorkflow(chunk)
+      end (chunk, _encoding, done) {
+        startWorkflow(chunk, models)
         done()
-      },
+      }
     })
 
     repository.list({ transform: rehydrate, writable: resumeWorkflow })