@cadenza.io/service 2.3.17 → 2.4.0

package/dist/index.js

@@ -330,10 +330,10 @@ var ServiceRegistry = class _ServiceRegistry {
         } = serviceInstance;
         if (uuid4 === this.serviceInstanceId) return;
         if (deleted) {
-          this.instances.get(serviceName)?.splice(
-            this.instances.get(serviceName)?.findIndex((i) => i.uuid === uuid4) ?? -1,
-            1
-          );
+          const indexToDelete = this.instances.get(serviceName)?.findIndex((i) => i.uuid === uuid4) ?? -1;
+          if (indexToDelete >= 0) {
+            this.instances.get(serviceName)?.splice(indexToDelete, 1);
+          }
           if (this.instances.get(serviceName)?.length === 0) {
             this.instances.delete(serviceName);
           } else if (this.instances.get(serviceName)?.filter((i) => i.address === address && i.port === port).length === 0) {
@@ -376,7 +376,7 @@ var ServiceRegistry = class _ServiceRegistry {
               communicationTypes
             });
             instances?.filter(
-              (i) => i.address === address && i.port === port && i.clientCreated && i.isActive
+              (i) => i.address === address && i.port === port && i.isActive
             ).forEach((i) => {
               i.clientCreated = true;
             });
@@ -480,7 +480,12 @@ var ServiceRegistry = class _ServiceRegistry {
         return true;
       },
       "Handles service not responding"
-    ).doOn("meta.fetch.handshake_failed", "meta.socket_client.disconnected").attachSignal("global.meta.service_registry.service_not_responding");
+    ).doOn(
+      "meta.fetch.handshake_failed",
+      "meta.fetch.handshake_failed.*",
+      "meta.socket_client.disconnected",
+      "meta.socket_client.disconnected.*"
+    ).attachSignal("global.meta.service_registry.service_not_responding");
     this.handleServiceHandshakeTask = CadenzaService.createMetaTask(
       "Handle service handshake",
       (ctx, emit) => {
@@ -507,7 +512,10 @@ var ServiceRegistry = class _ServiceRegistry {
           (i) => i.uuid !== serviceInstanceId && i.address === serviceAddress && i.port === servicePort
         );
         for (const i of instancesToDelete ?? []) {
-          this.instances.get(serviceName)?.splice(this.instances.get(serviceName)?.indexOf(i) ?? -1, 1);
+          const indexToDelete = this.instances.get(serviceName)?.indexOf(i) ?? -1;
+          if (indexToDelete >= 0) {
+            this.instances.get(serviceName)?.splice(indexToDelete, 1);
+          }
           emit("global.meta.service_registry.deleted", {
             data: {
               isActive: false,
@@ -667,8 +675,9 @@ var ServiceRegistry = class _ServiceRegistry {
         }
         if (__broadcast || instances[0].isFrontend) {
           for (const instance of instances) {
+            const socketKey = instance.isFrontend ? instance.address : `${instance.address}_${instance.port}`;
             emit(
-              `meta.service_registry.selected_instance_for_socket:${instance.address}`,
+              `meta.service_registry.selected_instance_for_socket:${socketKey}`,
               context
             );
           }
@@ -1659,6 +1668,46 @@ var RestController = class _RestController {
 var import_socket = require("socket.io");
 var import_rate_limiter_flexible2 = require("rate-limiter-flexible");
 var import_socket2 = require("socket.io-client");
+
+// src/network/socketClientUtils.ts
+var waitForSocketConnection = async (socket, timeoutMs, createError) => {
+  if (!socket) {
+    return { ok: false, error: createError("disconnected") };
+  }
+  if (socket.connected) {
+    return { ok: true };
+  }
+  return new Promise((resolve) => {
+    let timer = null;
+    let settled = false;
+    const cleanup = () => {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      socket.off("connect", onConnect);
+      socket.off("connect_error", onConnectError);
+      socket.off("disconnect", onDisconnect);
+    };
+    const settle = (outcome) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(outcome);
+    };
+    const onConnect = () => settle({ ok: true });
+    const onConnectError = (error) => settle({ ok: false, error: createError("connect_error", error) });
+    const onDisconnect = () => settle({ ok: false, error: createError("disconnected") });
+    socket.once("connect", onConnect);
+    socket.once("connect_error", onConnectError);
+    socket.once("disconnect", onDisconnect);
+    timer = setTimeout(() => {
+      settle({ ok: false, error: createError("connect_timeout") });
+    }, timeoutMs);
+  });
+};
+
+// src/network/SocketController.ts
 var SocketController = class _SocketController {
   static get instance() {
     if (!this._instance) this._instance = new _SocketController();
@@ -1934,35 +1983,71 @@ var SocketController = class _SocketController {
         });
         emitWhenReady = (event, data, timeoutMs = 6e4, ack) => {
           return new Promise((resolve) => {
-            const tryEmit = () => {
-              if (!socket?.connected) {
-                socket?.once("connect", tryEmit);
+            const resolveWithError = (errorMessage, fallbackError) => {
+              resolve({
+                ...data,
+                errored: true,
+                __error: errorMessage,
+                error: fallbackError instanceof Error ? fallbackError.message : errorMessage,
+                socketId: socket?.id,
+                serviceName,
+                URL
+              });
+            };
+            const tryEmit = async () => {
+              const waitTimeoutMs = timeoutMs > 0 ? timeoutMs + 10 : 1e4;
+              const waitResult = await waitForSocketConnection(
+                socket,
+                waitTimeoutMs,
+                (reason, error) => {
+                  if (reason === "connect_timeout") {
+                    return `Socket connect timed out before '${event}'`;
+                  }
+                  if (reason === "connect_error") {
+                    const errMessage = error instanceof Error ? error.message : String(error);
+                    return `Socket connect error before '${event}': ${errMessage}`;
+                  }
+                  return `Socket disconnected before '${event}'`;
+                }
+              );
+              if (!waitResult.ok) {
+                CadenzaService.log(
+                  waitResult.error,
+                  { socketId: socket?.id, serviceName, URL, event },
+                  "error"
+                );
+                resolveWithError(waitResult.error);
                 return;
               }
-              let timer;
+              let timer = null;
               if (timeoutMs !== 0) {
                 timer = setTimeout(() => {
+                  if (timer) {
+                    pendingTimers.delete(timer);
+                    timer = null;
+                  }
                   CadenzaService.log(
                     `Socket event '${event}' timed out`,
                     { socketId: socket?.id, serviceName, URL },
                     "error"
                   );
-                  resolve({
-                    ...data,
-                    errored: true,
-                    __error: `Socket event '${event}' timed out`,
-                    error: `Socket event '${event}' timed out`,
-                    socketId: socket?.id,
-                    serviceName,
-                    URL
-                  });
+                  resolveWithError(`Socket event '${event}' timed out`);
                 }, timeoutMs + 10);
                 pendingTimers.add(timer);
               }
-              socket.timeout(timeoutMs).emit(event, data, (err, response) => {
-                if (timer) clearTimeout(timer);
-                pendingTimers.delete(timer);
-                timer = null;
+              const connectedSocket = socket;
+              if (!connectedSocket) {
+                resolveWithError(
+                  `Socket unavailable before emitting '${event}'`
+                );
+                return;
+              }
+              connectedSocket.timeout(timeoutMs).emit(event, data, (err, response) => {
+                if (timer) {
+                  clearTimeout(timer);
+                  pendingTimers.delete(timer);
+                  timer = null;
+                }
                 if (err) {
                   CadenzaService.log(
                     "Socket timeout.",
@@ -1985,11 +2070,7 @@ var SocketController = class _SocketController {
                 resolve(response);
               });
             };
-            if (socket?.connected) {
-              tryEmit();
-            } else {
-              socket?.once("connect", tryEmit);
-            }
+            void tryEmit();
           });
         };
         socket.on("connect", () => {
@@ -2306,14 +2387,25 @@ var GraphMetadataController = class _GraphMetadataController {
       return {
         data: {
           ...ctx.data,
-          serviceName: CadenzaService.serviceRegistry.serviceName
-          // input_context_schema_id: ctx.data.inputContextSchema ? {  // TODO
-          //
-          // } : null,
-          // output_context_schema_id: ctx.data.outputContextSchema ? {
-          //
-          // } : null,
-        }
+          serviceName: CadenzaService.serviceRegistry.serviceName,
+          inputContextSchemaId: ctx.data.inputContextSchemaId ? {
+            subOperation: "insert",
+            table: "context_schema",
+            data: {
+              ...ctx.data.inputContextSchemaId
+            },
+            return: "uuid"
+          } : null,
+          outputContextSchemaId: ctx.data.outputContextSchemaId ? {
+            subOperation: "insert",
+            table: "context_schema",
+            data: {
+              ...ctx.data.outputContextSchemaId
+            },
+            return: "uuid"
+          } : null
+        },
+        transaction: true
       };
     }).doOn("meta.task.created").emits("global.meta.graph_metadata.task_created");
     CadenzaService.createMetaTask("Handle task update", (ctx) => {
@@ -3621,9 +3713,9 @@ var DatabaseController = class _DatabaseController {
   createDatabaseTask(op, tableName, table, queryFunction, options) {
     const opAction = op === "query" ? "queried" : op === "insert" ? "inserted" : op === "update" ? "updated" : op === "delete" ? "deleted" : "";
     const defaultSignal = `global.${options.isMeta ? "meta." : ""}${tableName}.${opAction}`;
-    const tableNameFormatted = tableName.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
-    const taskName = `db${op.charAt(0).toUpperCase() + op.slice(1)}${tableNameFormatted}`;
-    CadenzaService.createThrottledTask(
+    const taskName = `${op.charAt(0).toUpperCase() + op.slice(1)} ${tableName}`;
+    const schema = this.getInputSchema(op, tableName, table);
+    const task = CadenzaService.createThrottledTask(
       taskName,
       async (context, emit) => {
         for (const action of Object.keys(table.customSignals?.triggers ?? {})) {
@@ -3718,17 +3810,8 @@ var DatabaseController = class _DatabaseController {
       {
         isMeta: options.isMeta,
         isSubMeta: options.isMeta,
-        validateInputContext: false,
-        // TODO
-        inputSchema: {
-          // TODO
-          type: "object",
-          properties: {
-            filter: {
-              type: "object"
-            }
-          }
-        }
+        validateInputContext: options.securityProfile !== "low",
+        inputSchema: schema
       }
     ).doOn(
       ...table.customSignals?.triggers?.[op]?.map((signal) => {
@@ -3739,8 +3822,382 @@ var DatabaseController = class _DatabaseController {
         return typeof signal === "string" ? signal : signal.signal;
       }) ?? []
     );
+    if (op === "query") {
+      const intentName = `query-${CadenzaService.serviceRegistry.serviceName}-${tableName}`;
+      CadenzaService.defineIntent({
+        name: intentName,
+        description: `Perform a query operation on the ${tableName} table`,
+        input: schema
+      });
+      task.respondsTo(intentName);
+    }
+  }
+  getInputSchema(op, tableName, table) {
+    const inputSchema = {
+      type: "object",
+      properties: {
+        queryData: {
+          type: "object",
+          properties: {},
+          strict: true
+        }
+      },
+      strict: true
+    };
+    if (!inputSchema.properties) {
+      return inputSchema;
+    }
+    inputSchema.properties.transaction = getTransactionSchema();
+    inputSchema.properties.queryData.properties.transaction = inputSchema.properties.transaction;
+    switch (op) {
+      case "insert":
+        inputSchema.properties.data = getInsertDataSchemaFromTable(
+          table,
+          tableName
+        );
+        inputSchema.properties.queryData.properties.data = inputSchema.properties.data;
+        inputSchema.properties.batch = getQueryBatchSchemaFromTable();
+        inputSchema.properties.queryData.properties.batch = inputSchema.properties.batch;
+        inputSchema.properties.onConflict = getQueryOnConflictSchemaFromTable(
+          table,
+          tableName
+        );
+        inputSchema.properties.queryData.properties.onConflict = inputSchema.properties.onConflict;
+        break;
+      case "query":
+        inputSchema.properties.filter = getQueryFilterSchemaFromTable(
+          table,
+          tableName
+        );
+        inputSchema.properties.queryData.properties.filter = inputSchema.properties.filter;
+        inputSchema.properties.fields = getQueryFieldsSchemaFromTable(
+          table,
+          tableName
+        );
+        inputSchema.properties.queryData.properties.fields = inputSchema.properties.fields;
+        inputSchema.properties.joins = getQueryJoinsSchemaFromTable(
+          table,
+          tableName
+        );
+        inputSchema.properties.queryData.properties.joins = inputSchema.properties.joins;
+        inputSchema.properties.sort = getQuerySortSchemaFromTable(
+          table,
+          tableName
+        );
+        inputSchema.properties.queryData.properties.sort = inputSchema.properties.sort;
+        inputSchema.properties.limit = getQueryLimitSchemaFromTable();
+        inputSchema.properties.queryData.properties.limit = inputSchema.properties.limit;
+        inputSchema.properties.offset = getQueryOffsetSchemaFromTable();
+        inputSchema.properties.queryData.properties.offset = inputSchema.properties.offset;
+        break;
+      case "update":
+        inputSchema.properties.filter = getQueryFilterSchemaFromTable(
+          table,
+          tableName
+        );
+        inputSchema.properties.queryData.properties.filter = inputSchema.properties.filter;
+        inputSchema.properties.fields = getQueryFieldsSchemaFromTable(
+          table,
+          tableName
+        );
+        inputSchema.properties.queryData.properties.fields = inputSchema.properties.fields;
+        break;
+      case "delete":
+        inputSchema.properties.filter = getQueryFilterSchemaFromTable(
+          table,
+          tableName
+        );
+        inputSchema.properties.queryData.properties.filter = inputSchema.properties.filter;
+        break;
+    }
+    return inputSchema;
   }
 };
+function getInsertDataSchemaFromTable(table, tableName) {
+  const dataSchema = {
+    type: "object",
+    properties: {
+      ...Object.fromEntries(
+        Object.entries(table.fields).map((field) => {
+          return [
+            field[0],
+            [
+              {
+                type: tableFieldTypeToSchemaType(field[1].type),
+                description: `Inferred from field '${field[0]}' of type [${field[1].type}] on table ${tableName}.`
+              },
+              {
+                type: "string",
+                constraints: {
+                  oneOf: ["increment", "decrement", "set"]
+                }
+              },
+              {
+                type: "object",
+                properties: {
+                  subOperation: {
+                    type: "string",
+                    enum: ["insert", "query"]
+                  },
+                  table: {
+                    type: "string"
+                  },
+                  data: [
+                    {
+                      type: "object"
+                    },
+                    {
+                      type: "array",
+                      items: {
+                        type: "object"
+                      }
+                    }
+                  ],
+                  filter: {
+                    type: "object"
+                  },
+                  fields: {
+                    type: "array",
+                    items: {
+                      type: "string"
+                    }
+                  },
+                  return: {
+                    type: "string"
+                  }
+                },
+                required: ["subOperation", "table"]
+              }
+            ]
+          ];
+        })
+      )
+    },
+    required: Object.entries(table.fields).filter((field) => field[1].required || field[1].primary).map((field) => field[0]),
+    strict: true
+  };
+  return [
+    dataSchema,
+    {
+      type: "array",
+      items: dataSchema
+    }
+  ];
+}
+function getQueryFilterSchemaFromTable(table, tableName) {
+  return {
+    type: "object",
+    properties: {
+      ...Object.fromEntries(
+        Object.entries(table.fields).map((field) => {
+          return [
+            field[0],
+            [
+              {
+                type: tableFieldTypeToSchemaType(field[1].type),
+                description: `Inferred from field '${field[0]}' of type [${field[1].type}] on table ${tableName}.`
+              },
+              {
+                type: "array",
+                items: {
+                  type: tableFieldTypeToSchemaType(field[1].type)
+                }
+              }
+            ]
+          ];
+        })
+      )
+    },
+    strict: true,
+    description: `Inferred from table '${tableName}' on database service ${CadenzaService.serviceRegistry.serviceName}.`
+  };
+}
+function getQueryFieldsSchemaFromTable(table, tableName) {
+  return {
+    type: "array",
+    items: {
+      type: "string",
+      constraints: {
+        oneOf: Object.keys(table.fields)
+      }
+    },
+    description: `Inferred from table '${tableName}' on database service ${CadenzaService.serviceRegistry.serviceName}.`
+  };
+}
+function getQueryJoinsSchemaFromTable(table, tableName) {
+  return {
+    type: "object",
+    properties: {
+      ...Object.fromEntries(
+        Object.entries(table.fields).map((field) => {
+          return [
+            field[0],
+            {
+              type: "object",
+              properties: {
+                on: {
+                  type: "string"
+                },
+                fields: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                },
+                filter: {
+                  type: "object"
+                },
+                returnAs: {
+                  type: "string",
+                  constraints: {
+                    oneOf: ["array", "object"]
+                  }
+                },
+                alias: {
+                  type: "string"
+                },
+                joins: {
+                  type: "object"
+                }
+              },
+              required: ["on", "fields"],
+              strict: true
+            }
+          ];
+        })
+      )
+    },
+    strict: true,
+    description: `Inferred from table '${tableName}' on database service ${CadenzaService.serviceRegistry.serviceName}.`
+  };
+}
+function getQuerySortSchemaFromTable(table, tableName) {
+  return {
+    type: "object",
+    properties: {
+      ...Object.fromEntries(
+        Object.entries(table.fields).map((field) => {
+          return [
+            field[0],
+            {
+              type: "string",
+              constraints: {
+                oneOf: ["asc", "desc"]
+              }
+            }
+          ];
+        })
+      )
+    },
+    strict: true,
+    description: `Inferred from table '${tableName}' on database service ${CadenzaService.serviceRegistry.serviceName}.`
+  };
+}
+function getQueryLimitSchemaFromTable() {
+  return {
+    type: "number",
+    constraints: {
+      min: 1
+    },
+    description: "Limit for query results"
+  };
+}
+function getQueryOffsetSchemaFromTable() {
+  return {
+    type: "number",
+    constraints: {
+      min: 0
+    },
+    description: "Offset for query results"
+  };
+}
+function getTransactionSchema() {
+  return {
+    type: "boolean",
+    description: "Whether to run the query in a transaction"
+  };
+}
+function getQueryBatchSchemaFromTable() {
+  return {
+    type: "boolean",
+    description: "Whether to run the query in batch mode"
+  };
+}
+function getQueryOnConflictSchemaFromTable(table, tableName) {
+  return {
+    type: "object",
+    properties: {
+      target: {
+        type: "array",
+        items: {
+          type: "string",
+          constraints: {
+            oneOf: Object.keys(table.fields)
+          }
+        }
+      },
+      action: {
+        type: "object",
+        properties: {
+          do: {
+            type: "string",
+            constraints: {
+              oneOf: ["nothing", "update"]
+            }
+          },
+          set: {
+            type: "object",
+            properties: {
+              ...Object.fromEntries(
+                Object.entries(table.fields).map((field) => {
+                  return [
+                    field[0],
+                    [
+                      {
+                        type: tableFieldTypeToSchemaType(field[1].type),
+                        description: `Inferred from field '${field[0]}' of type [${field[1].type}] on table ${tableName}.`
+                      }
+                    ]
+                  ];
+                })
+              )
+            }
+          },
+          where: {
+            type: "string"
+          }
+        },
+        required: ["do"]
+      }
+    },
+    required: ["target", "action"],
+    strict: true
+  };
+}
+function tableFieldTypeToSchemaType(type) {
+  switch (type) {
+    case "varchar":
+    case "text":
+    case "jsonb":
+    case "uuid":
+    case "date":
+    case "geo_point":
+    case "bytea":
+      return "string";
+    case "int":
+    case "bigint":
+    case "decimal":
+    case "timestamp":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "array":
+      return "array";
+    case "object":
+      return "object";
+  }
+  return "any";
+}
 
 // src/Cadenza.ts
 var import_uuid3 = require("uuid");
@@ -4614,10 +5071,9 @@ var CadenzaService = class {
     this.bootstrap();
     this.validateName(tableName);
     this.validateName(operation);
-    const tableNameFormatted = tableName.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
     const name = `${operation.charAt(0).toUpperCase() + operation.slice(1)} ${tableName} in ${databaseServiceName ?? "default database service"}`;
     const description = `Executes a ${operation} on table ${tableName} in ${databaseServiceName ?? "default database service"}`;
-    const taskName = `db${operation.charAt(0).toUpperCase() + operation.slice(1)}${tableNameFormatted}`;
+    const taskName = `${operation.charAt(0).toUpperCase() + operation.slice(1)} ${tableName}`;
     options = {
       concurrency: 100,
       timeout: 0,
@@ -4879,7 +5335,7 @@ var CadenzaService = class {
    * This method is not supported in a browser environment and will log a warning if called in such an environment.
    *
    * @param {string} name - The name of the database service to be created.
-   * @param {SchemaDefinition} schema - The schema definition for the database service.
+   * @param {DatabaseSchemaDefinition} schema - The schema definition for the database service.
    * @param {string} [description=""] - An optional description of the database service.
    * @param {ServerOptions & DatabaseOptions} [options={}] - Optional configuration settings for the database and server.
    * @return {void} This method does not return a value.
@@ -4943,7 +5399,7 @@ var CadenzaService = class {
    * Creates a meta database service with the specified configuration.
    *
    * @param {string} name - The name of the database service to be created.
-   * @param {SchemaDefinition} schema - The schema definition for the database.
+   * @param {DatabaseSchemaDefinition} schema - The schema definition for the database.
    * @param {string} [description=""] - An optional description of the database service.
    * @param {ServerOptions & DatabaseOptions} [options={}] - Optional server and database configuration options. The `isMeta` flag will be automatically set to true.
    * @return {void} - This method does not return a value.