@ruiapp/rapid-core 0.1.35 → 0.1.37

package/dist/index.js

@@ -3339,8 +3339,12 @@ async function handler$h(plugin, ctx, options) {
     if (operation) {
         delete mergedInput.$operation;
     }
+    const stateProperties = mergedInput.$stateProperties;
+    if (stateProperties) {
+        delete mergedInput.$stateProperties;
+    }
     const entityManager = server.getEntityManager(options.singularCode);
-    const output = await entityManager.updateEntityById({ id: mergedInput.id, entityToSave: mergedInput, operation }, plugin);
+    const output = await entityManager.updateEntityById({ id: mergedInput.id, entityToSave: mergedInput, operation, stateProperties }, plugin);
     ctx.output = output;
 }
 
@@ -5036,7 +5040,6 @@ class CronJobPlugin {
 }
 
 async function getStateMachineNextSnapshot(server, options) {
-    debugger;
     const { machineConfig, currentState, event } = options;
     machineConfig.initial = currentState;
     const machine = xstate.createMachine(machineConfig);
@@ -5256,36 +5259,45 @@ class StateMachinePlugin {
      */
     async beforeUpdateEntity(server, model, options, currentEntity) {
         const entity = options.entityToSave;
+        const stateMachineEnabledProperties = [];
         for (const property of model.properties) {
             const isStateMachineEnabled = lodash.get(property.config, "stateMachine.enabled", false);
-            const isTransferControlEnabled = lodash.get(property.config, "stateMachine.transferControl", false);
-            if (isStateMachineEnabled && isTransferControlEnabled && !isNullOrUndefined(entity[property.code])) {
-                throw new Error(`You're not allowed to change '${property.code}' property directly when transfer control is enabled, do an operation instead.`);
+            if (isStateMachineEnabled) {
+                stateMachineEnabledProperties.push(property);
+                const isTransferControlEnabled = lodash.get(property.config, "stateMachine.transferControl", false);
+                if (isTransferControlEnabled && !isNullOrUndefined(entity[property.code])) {
+                    throw new Error(`You're not allowed to change '${property.code}' property directly when transfer control is enabled, do an operation instead.`);
+                }
             }
         }
         if (!options.operation) {
             return;
         }
-        const stateMachineEnabledProperties = lodash.filter(model.properties, (property) => lodash.get(property.config, "stateMachine.enabled", false));
-        let stateMachineEnabledProperty = lodash.first(stateMachineEnabledProperties);
-        if (options.stateProperty) {
-            stateMachineEnabledProperty = lodash.find(stateMachineEnabledProperties, (property) => property.code === options.stateProperty);
+        let statePropertiesToUpdate;
+        const statePropertyCodes = options.stateProperties;
+        if (statePropertyCodes && statePropertyCodes.length) {
+            statePropertiesToUpdate = lodash.filter(stateMachineEnabledProperties, (property) => statePropertyCodes.includes(property.code));
+        }
+        else {
+            statePropertiesToUpdate = stateMachineEnabledProperties;
         }
-        if (!stateMachineEnabledProperty) {
+        if (!statePropertiesToUpdate.length) {
             throw new Error(`State machine property not found.`);
         }
-        const machineConfig = lodash.get(stateMachineEnabledProperty.config, "stateMachine.config", null);
-        if (!machineConfig) {
-            throw new Error(`State machine of property '${stateMachineEnabledProperty.code}' not configured.`);
+        for (const statePropertyToUpdate of statePropertiesToUpdate) {
+            const machineConfig = lodash.get(statePropertyToUpdate.config, "stateMachine.config", null);
+            if (!machineConfig) {
+                throw new Error(`State machine of property '${statePropertyToUpdate.code}' not configured.`);
+            }
+            machineConfig.id = getStateMachineCode(model, statePropertyToUpdate);
+            const nextSnapshot = await getStateMachineNextSnapshot(server, {
+                machineConfig,
+                context: {},
+                currentState: currentEntity[statePropertyToUpdate.code],
+                event: options.operation,
+            });
+            entity[statePropertyToUpdate.code] = nextSnapshot.value;
         }
-        machineConfig.id = getStateMachineCode(model, stateMachineEnabledProperty);
-        const nextSnapshot = await getStateMachineNextSnapshot(server, {
-            machineConfig,
-            context: {},
-            currentState: currentEntity[stateMachineEnabledProperty.code],
-            event: options.operation,
-        });
-        entity[stateMachineEnabledProperty.code] = nextSnapshot.value;
     }
 }
 function getStateMachineCode(model, property) {

package/dist/plugins/stateMachine/StateMachinePluginTypes.d.ts

@@ -1,4 +1,4 @@
-import { MachineConfig } from "xstate";
+import { AnyActorRef, AnyEventObject, EventObject, MachineConfig, MachineContext, MachineSnapshot, MetaObject, StateValue } from "xstate";
 export type PropertyStateMachineConfig = {
     enabled: boolean;
     config: MachineConfig<any, any>;
@@ -7,18 +7,25 @@ export type PropertyStateMachineConfig = {
 export type SendStateMachineEventOptions = {
     code: string;
 };
+export type StateMachineEvent = AnyEventObject;
 export type SendStateMachineEventInput = {
     code?: string;
     context: any;
     currentState: string;
     event: StateMachineEvent;
 };
-export type StateMachineEvent = {
-    type: string;
-};
 export type GetStateMachineNextSnapshotOptions = {
     machineConfig: MachineConfig<any, any>;
     context: any;
     currentState: string;
     event: StateMachineEvent;
 };
+export type DefaultStateMachineSnapshot = MachineSnapshot<MachineContext, EventObject, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, MetaObject>;
+export type TryGetStateMachineNextSnapshotResult = TryGetStateMachineNextSnapshotPositiveResult | TryGetStateMachineNextSnapshotNegativeResult;
+export type TryGetStateMachineNextSnapshotPositiveResult = {
+    canTransfer: true;
+    nextSnapshot: DefaultStateMachineSnapshot;
+};
+export type TryGetStateMachineNextSnapshotNegativeResult = {
+    canTransfer: false;
+};

package/dist/plugins/stateMachine/StateMachineService.d.ts

@@ -1,3 +1,4 @@
 import { IRpdServer } from "../../core/server";
-import { GetStateMachineNextSnapshotOptions } from "./StateMachinePluginTypes";
+import { GetStateMachineNextSnapshotOptions, TryGetStateMachineNextSnapshotResult } from "./StateMachinePluginTypes";
 export declare function getStateMachineNextSnapshot(server: IRpdServer, options: GetStateMachineNextSnapshotOptions): Promise<import("xstate").MachineSnapshot<any, import("xstate").AnyEventObject, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, import("xstate").MetaObject, never>>;
+export declare function tryGetStateMachineNextSnapshot(server: IRpdServer, options: GetStateMachineNextSnapshotOptions): Promise<TryGetStateMachineNextSnapshotResult>;

package/dist/types.d.ts

@@ -355,7 +355,7 @@ export interface UpdateEntityByIdOptions {
     id: any;
     entityToSave: any;
     operation?: any;
-    stateProperty?: string;
+    stateProperties?: string[];
 }
 export interface DeleteEntityOptions {
     filters?: EntityFilterOptions[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruiapp/rapid-core",
-  "version": "0.1.35",
+  "version": "0.1.37",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/plugins/dataManage/actionHandlers/updateCollectionEntityById.ts

@@ -16,13 +16,17 @@ export async function handler(
   const mergedInput = mergeInput(defaultInput, input, fixedInput);
   logger.debug(`Running ${code} handler...`, { defaultInput, fixedInput, mergedInput });
 
-
   const operation = mergedInput.$operation;
   if (operation) {
     delete mergedInput.$operation;
   }
 
+  const stateProperties = mergedInput.$stateProperties;
+  if (stateProperties) {
+    delete mergedInput.$stateProperties;
+  }
+
   const entityManager = server.getEntityManager(options.singularCode);
-  const output = await entityManager.updateEntityById({ id: mergedInput.id, entityToSave: mergedInput, operation }, plugin);
+  const output = await entityManager.updateEntityById({ id: mergedInput.id, entityToSave: mergedInput, operation, stateProperties }, plugin);
   ctx.output = output;
 }

package/src/plugins/stateMachine/StateMachinePlugin.ts

@@ -127,12 +127,17 @@ class StateMachinePlugin implements RapidPlugin {
   async beforeUpdateEntity(server: IRpdServer, model: RpdDataModel, options: UpdateEntityByIdOptions, currentEntity: any) {
     const entity = options.entityToSave;
 
+    const stateMachineEnabledProperties: RpdDataModelProperty[] = [];
     for (const property of model.properties) {
       const isStateMachineEnabled = get(property.config, "stateMachine.enabled", false);
-      const isTransferControlEnabled = get(property.config, "stateMachine.transferControl", false);
-      if (isStateMachineEnabled && isTransferControlEnabled && !isNullOrUndefined(entity[property.code])
-      ) {
-        throw new Error(`You're not allowed to change '${property.code}' property directly when transfer control is enabled, do an operation instead.`);
+
+      if (isStateMachineEnabled) {
+        stateMachineEnabledProperties.push(property);
+
+        const isTransferControlEnabled = get(property.config, "stateMachine.transferControl", false);
+        if (isTransferControlEnabled && !isNullOrUndefined(entity[property.code])) {
+          throw new Error(`You're not allowed to change '${property.code}' property directly when transfer control is enabled, do an operation instead.`);
+        }
       }
     }
 
@@ -140,32 +145,35 @@ class StateMachinePlugin implements RapidPlugin {
       return;
     }
 
-    const stateMachineEnabledProperties = filter(model.properties, (property) => get(property.config, "stateMachine.enabled", false)) as RpdDataModelProperty[];
-    let stateMachineEnabledProperty = first(stateMachineEnabledProperties);
-    if (options.stateProperty) {
-      stateMachineEnabledProperty = find(stateMachineEnabledProperties, (property) => property.code === options.stateProperty);
+    let statePropertiesToUpdate: RpdDataModelProperty[];
+    const statePropertyCodes = options.stateProperties;
+    if (statePropertyCodes && statePropertyCodes.length) {
+      statePropertiesToUpdate = filter(stateMachineEnabledProperties, (property) => statePropertyCodes.includes(property.code));
+    } else {
+      statePropertiesToUpdate = stateMachineEnabledProperties;
     }
 
-    if (!stateMachineEnabledProperty) {
+    if (!statePropertiesToUpdate.length) {
       throw new Error(`State machine property not found.`);
     }
 
-    const machineConfig = get(stateMachineEnabledProperty.config, "stateMachine.config", null);
-    if (!machineConfig) {
-      throw new Error(`State machine of property '${stateMachineEnabledProperty.code}' not configured.`);
+    for (const statePropertyToUpdate of statePropertiesToUpdate) {
+      const machineConfig = get(statePropertyToUpdate.config, "stateMachine.config", null);
+      if (!machineConfig) {
+        throw new Error(`State machine of property '${statePropertyToUpdate.code}' not configured.`);
+      }
+      machineConfig.id = getStateMachineCode(model, statePropertyToUpdate);
+  
+      const nextSnapshot = await getStateMachineNextSnapshot(server, {
+        machineConfig,
+        context: {},
+        currentState: currentEntity[statePropertyToUpdate.code],
+        event: options.operation,
+      });
+  
+      entity[statePropertyToUpdate.code] = nextSnapshot.value;
     }
-    machineConfig.id = getStateMachineCode(model, stateMachineEnabledProperty);
-
-    const nextSnapshot = await getStateMachineNextSnapshot(server, {
-      machineConfig,
-      context: {},
-      currentState: currentEntity[stateMachineEnabledProperty.code],
-      event: options.operation,
-    });
-
-    entity[stateMachineEnabledProperty.code] = nextSnapshot.value;
   }
-
 }
 
 function getStateMachineCode(model: RpdDataModel, property: RpdDataModelProperty) {

package/src/plugins/stateMachine/StateMachinePluginTypes.ts

@@ -1,4 +1,4 @@
-import { MachineConfig } from "xstate";
+import { AnyActorRef, AnyEventObject, EventObject, MachineConfig, MachineContext, MachineSnapshot, MetaObject, StateValue } from "xstate";
 
 
 export type PropertyStateMachineConfig = {
@@ -11,6 +11,8 @@ export type SendStateMachineEventOptions = {
   code: string;
 }
 
+export type StateMachineEvent = AnyEventObject;
+
 export type SendStateMachineEventInput = {
   code?: string;
   context: any;
@@ -18,13 +20,22 @@ export type SendStateMachineEventInput = {
   event: StateMachineEvent;
 }
 
-export type StateMachineEvent = {
-  type: string;
-}
-
 export type GetStateMachineNextSnapshotOptions = {
   machineConfig: MachineConfig<any, any>;
   context: any;
   currentState: string;
   event: StateMachineEvent;
+}
+
+export type DefaultStateMachineSnapshot = MachineSnapshot<MachineContext, EventObject, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, MetaObject>;
+
+export type TryGetStateMachineNextSnapshotResult = TryGetStateMachineNextSnapshotPositiveResult | TryGetStateMachineNextSnapshotNegativeResult;
+
+export type TryGetStateMachineNextSnapshotPositiveResult = {
+  canTransfer: true;
+  nextSnapshot: DefaultStateMachineSnapshot;
+}
+
+export type TryGetStateMachineNextSnapshotNegativeResult = {
+  canTransfer: false;
 }

package/src/plugins/stateMachine/StateMachineService.ts

@@ -1,9 +1,8 @@
 import { IRpdServer } from "~/core/server";
-import { GetStateMachineNextSnapshotOptions } from "./StateMachinePluginTypes";
+import { DefaultStateMachineSnapshot, GetStateMachineNextSnapshotOptions, TryGetStateMachineNextSnapshotResult } from "./StateMachinePluginTypes";
 import { createMachine, getInitialSnapshot, getNextSnapshot } from "xstate";
 
 export async function getStateMachineNextSnapshot(server: IRpdServer, options: GetStateMachineNextSnapshotOptions) {
-  debugger
   const { machineConfig, currentState, event } = options;
   machineConfig.initial = currentState;
 
@@ -17,3 +16,22 @@ export async function getStateMachineNextSnapshot(server: IRpdServer, options: G
   const nextSnapshot = getNextSnapshot(machine, snapshot, event);
   return nextSnapshot;
 }
+
+export async function tryGetStateMachineNextSnapshot(server: IRpdServer, options: GetStateMachineNextSnapshotOptions): Promise<TryGetStateMachineNextSnapshotResult> {
+  const { machineConfig, currentState, event } = options;
+  machineConfig.initial = currentState;
+
+  const machine = createMachine(machineConfig);
+  const snapshot = getInitialSnapshot(machine);
+
+  const canTransfer = snapshot.can(event);
+  let nextSnapshot: DefaultStateMachineSnapshot;
+  if (canTransfer) {
+    nextSnapshot = getNextSnapshot(machine, snapshot, event);
+  }
+
+  return {
+    canTransfer,
+    nextSnapshot,
+  };
+}

package/src/types.ts

@@ -474,7 +474,7 @@ export interface UpdateEntityByIdOptions {
   id: any;
   entityToSave: any;
   operation?: any;
-  stateProperty?: string;
+  stateProperties?: string[];
 }
 
 export interface DeleteEntityOptions {