@prostgles/prostgles 2.3.6-dev.1786565331 → 2.3.6-dev.1786615880

package/src/McpHub/ProstglesMcpHub/ProstglesMCPServers/Prostgles/agenticWorkflow/runtimeSdk/defineAgenticWorkflowHandlers.types.ts

@@ -0,0 +1,72 @@
+import type { DefineAgenticWorkflow } from "./defineAgenticWorkflow";
+
+export type ProxyDbCallData =
+  | {
+      type: "db/execute_sql" | "db/execute_readonly_sql";
+      sql: string;
+      query_timeout?: number;
+      query_params?: unknown[] | Record<string, unknown>;
+    }
+  | {
+      type: "db/find" | "db/count";
+      tableName: string;
+      filter?: any;
+      limit?: any;
+      select?: any;
+      orderBy?: any;
+      offset?: any;
+    }
+  | {
+      type: "db/insert" | "db/insertMany";
+      tableName: string;
+      data: any;
+      returning?: any;
+      onConflict?: any;
+    }
+  | {
+      type: "db/update";
+      tableName: string;
+      filter: any;
+      data: any;
+      returning?: any;
+      onConflict?: any;
+    }
+  | {
+      type: "db/delete";
+      tableName: string;
+      filter: any;
+      returning?: any;
+    };
+export type AgenticWorkflowDefinition = Parameters<DefineAgenticWorkflow>[0];
+export type ProxyCallDataDefinitions = {
+  type: "definitions";
+  definitions: Parameters<DefineAgenticWorkflow>[0];
+  usedTables: string[];
+};
+export type ProxyCallData =
+  | ProxyCallDataDefinitions
+  | {
+      type: "agent";
+      agentName: string;
+      input: string;
+    }
+  | {
+      type: "tool";
+      toolName: string;
+      serverName: string;
+      input: Record<string, unknown> | undefined;
+    }
+  | {
+      type: "progress";
+      percent: number;
+      message: string;
+    }
+  | ProxyDbCallData;
+
+const { DOCKER_MCP_ENDPOINT, MODE, USER_INPUT, EXECUTION_MODE } = process.env;
+export const WORKFLOW_ENV_VARS = {
+  DOCKER_MCP_ENDPOINT,
+  MODE,
+  USER_INPUT,
+  EXECUTION_MODE,
+};

package/src/McpHub/ProstglesMcpHub/ProstglesMCPServers/Prostgles/agenticWorkflow/runtimeSdk/definitionHandler.ts

@@ -0,0 +1,104 @@
+import ts from "typescript";
+import { callWorkflowProxy } from "./callWorkflowProxy";
+import { type DefineAgenticWorkflow } from "./defineAgenticWorkflow";
+
+export const definitionHandler = async (
+  definitions: Parameters<DefineAgenticWorkflow>[0],
+) => {
+  const usedTables = extractTableNames();
+  await callWorkflowProxy({
+    type: "definitions",
+    definitions,
+    usedTables,
+  });
+  console.log(
+    "Definitions sent to MCP proxy, exiting due to MODE=definitions-only",
+  );
+  process.exit(0);
+};
+const dbTableMethods = new Set([
+  "find",
+  "findOne",
+  "insert",
+  "update",
+  "delete",
+  "count",
+  "upsert",
+  "findOneOrCreate",
+]);
+
+const extractTableNames = (): string[] => {
+  const configPath = ts.findConfigFile(
+    __dirname,
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    ts.sys.fileExists,
+    "tsconfig.json",
+  );
+  if (!configPath) throw new Error("tsconfig.json not found");
+
+  // eslint-disable-next-line @typescript-eslint/unbound-method
+  const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+  const parsed = ts.parseJsonConfigFileContent(
+    configFile.config,
+    ts.sys,
+    __dirname,
+  );
+
+  const program = ts.createProgram(parsed.fileNames, parsed.options);
+  const sourceFile = program.getSourceFile(`${__dirname}/index.ts`);
+  if (!sourceFile) throw new Error("index.ts not found");
+
+  const checker = program.getTypeChecker();
+  const tables: string[] = [];
+
+  /**
+   * Matches both:
+   *   - `db.tableName.method()` where `db` is a destructured DbTableHandler
+   *   - `databaseHandler.db.tableName.method()` where the parent is DatabaseHandler
+   */
+  const isDbTableHandlerExpr = (node: ts.Expression): boolean => {
+    const type = checker.getTypeAtLocation(node);
+
+    // Covers the destructured case: `const { db } = databaseHandler`
+    if (type.aliasSymbol?.getName() === "DbTableHandler") return true;
+
+    // Covers the direct property access case: `databaseHandler.db`
+    if (ts.isPropertyAccessExpression(node) && node.name.text === "db") {
+      const parentType = checker.getTypeAtLocation(node.expression);
+      const parentSymbol = parentType.aliasSymbol ?? parentType.getSymbol();
+      return parentSymbol?.getName() === "DatabaseHandler";
+    }
+
+    return false;
+  };
+
+  const visit = (node: ts.Node): void => {
+    /**
+     * Target AST shape:
+     *   CallExpression
+     *     PropertyAccessExpression          <- `.method()`
+     *       PropertyAccessExpression        <- `.tableName`  ← extract this
+     *         Expression (DbTableHandler)   <- `db`
+     */
+    if (ts.isCallExpression(node)) {
+      const expr = node.expression;
+      if (
+        ts.isPropertyAccessExpression(expr) &&
+        dbTableMethods.has(expr.name.text)
+      ) {
+        const tableAccess = expr.expression;
+        if (
+          ts.isPropertyAccessExpression(tableAccess) &&
+          isDbTableHandlerExpr(tableAccess.expression)
+        ) {
+          tables.push(tableAccess.name.text);
+        }
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  };
+
+  visit(sourceFile);
+  return Array.from(new Set(tables));
+};

package/src/McpHub/ProstglesMcpHub/ProstglesMCPServers/Prostgles/agenticWorkflow/runtimeSdk/ensureWorkflowIsExecuted.ts

@@ -0,0 +1,53 @@
+import { WORKFLOW_ENV_VARS } from "./defineAgenticWorkflowHandlers.types";
+
+export const assertWorkflowStarted = (runState: { wasStarted: boolean }) => {
+  if (!WORKFLOW_ENV_VARS.DOCKER_MCP_ENDPOINT) {
+    // Not running inside container
+    return;
+  }
+
+  process.on("unhandledRejection", (reason) => {
+    console.error("Unhandled Rejection:\n", reason);
+    process.exit(1);
+  });
+
+  process.on("uncaughtException", (error) => {
+    console.error("Uncaught Exception:\n", error);
+    process.exit(1);
+  });
+
+  setTimeout(() => {
+    if (runState.wasStarted) {
+      return;
+    }
+    console.error(`
+defineAgenticWorkflow was not called within 1 second of the container starting. 
+This likely means there is an error in your workflow code that is preventing it from running, or you are not using defineAgenticWorkflow correctly.
+When generating workflow code, you MUST:
+
+1. Use defineAgenticWorkflow() - NOT exported functions
+2. Structure must be:
+
+\`\`\`typescript
+import { defineAgenticWorkflow } from "./defineAgenticWorkflow";
+void defineAgenticWorkflow(
+  {
+    name: "Workflow Name",
+    // workflow parameters
+  },
+  async ({ agentName }) => {
+    // workflow logic
+  },
+);
+\`\`\`
+
+3. DO NOT use:
+   - export default function
+   - export const myWorkflow
+   - Any other export syntax
+
+4. The workflow callback is the SECOND argument to defineAgenticWorkflow
+`);
+    process.exit(1);
+  }, 1000);
+};