@cascaide-ts/postgres-js 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2026 Cascaide
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,136 @@
+var l=Object.defineProperty;var I=Object.getOwnPropertyDescriptor;var T=Object.getOwnPropertyNames;var C=Object.prototype.hasOwnProperty;var x=(r,t)=>{for(var a in t)l(r,a,{get:t[a],enumerable:!0})},R=(r,t,a,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let e of T(t))!C.call(r,e)&&e!==a&&l(r,e,{get:()=>t[e],enumerable:!(n=I(t,e))||n.enumerable});return r};var S=r=>R(l({},"__esModule",{value:!0}),r);var y={};x(y,{PostgresPersistor:()=>u});module.exports=S(y);var f=require("crypto"),u=class{constructor(t){this.sql=t}async claimNodeExecution(t){let a=performance.now(),{nodeInstanceId:n,cascadeId:e,userId:s,nodeName:c,functionId:o,inputContext:d,location:i}=t;console.log("Claiming node execution:",{cascadeId:e,nodeName:c,requestedId:o});let _=(0,f.randomUUID)(),m=await this.sql.begin(async N=>{let E=await N`
+        WITH conflict_check AS (
+          -- Single aggregation combining conflict detection and MAX calculation
+          -- More efficient than separate EXISTS and MAX queries
+          SELECT 
+            CASE 
+              WHEN COUNT(*) FILTER (WHERE function_id = ${o}) > 0 
+              THEN MAX(function_id) + 1
+              ELSE ${o}
+            END as next_fn_id
+          FROM node_executions 
+          WHERE cascade_id = ${e}
+        ),
+        cascade_upsert AS (
+          INSERT INTO cascades (id, user_id, status, fn_id, created_at, updated_at)
+          SELECT ${e}, ${s}, 'RUNNING', next_fn_id, NOW(), NOW()
+          FROM conflict_check
+          ON CONFLICT (id) DO UPDATE 
+            SET fn_id = EXCLUDED.fn_id, updated_at = NOW()
+          RETURNING fn_id
+        )
+        INSERT INTO node_executions (
+          id, 
+          node_instance_id, 
+          cascade_id, 
+          node_name, 
+          function_id, 
+          input_context, 
+          location, 
+          status, 
+          started_at
+        )
+        SELECT 
+          ${_}, 
+          ${n}, 
+          ${e}, 
+          ${c}, 
+          fn_id, 
+          ${this.sql.json(d)}, 
+          ${i}, 
+          'RUNNING', 
+          NOW()
+        FROM cascade_upsert
+        RETURNING status, function_id as "functionId"
+      `;return{status:E[0].status,functionId:Number(E[0].functionId)}}),p=performance.now()-a;return console.log(`claimNodeExecution latency: ${p.toFixed(2)}ms`,{cascadeId:e,nodeName:c}),m}async finalizeNodeExecution(t){let a=performance.now(),{nodeInstanceId:n,cascadeId:e,fullOutput:s,hasSpawns:c}=t,o=await this.sql.begin(async i=>(await i`
+        WITH updated_node AS (
+          UPDATE node_executions
+          SET 
+            status = 'COMPLETED',
+            full_output = ${this.sql.json(s)},
+            completed_at = NOW()
+          WHERE node_instance_id = ${n}
+          RETURNING cascade_id
+        )
+        UPDATE cascades
+        SET status = 'COMPLETED', updated_at = NOW()
+        WHERE id IN (SELECT cascade_id FROM updated_node)
+          AND ${!c}
+      `,{status:"COMPLETED"})),d=performance.now()-a;return console.log(`finalizeNodeExecution latency: ${d.toFixed(2)}ms`,{cascadeId:e,nodeInstanceId:n}),o}async markExecutionFailed(t,a,n){let e=performance.now(),s=await this.sql.begin(async o=>(await o`
+        WITH updated_node AS (
+          UPDATE node_executions
+          SET status = 'FAILED', error = ${n}, completed_at = NOW()
+          WHERE node_instance_id = ${t}
+          RETURNING cascade_id
+        )
+        UPDATE cascades
+        SET status = 'ERROR', updated_at = NOW()
+        WHERE id IN (SELECT cascade_id FROM updated_node)
+      `,{status:"FAILED"})),c=performance.now()-e;return console.log(`markExecutionFailed latency: ${c.toFixed(2)}ms`,{cascadeId:a,nodeInstanceId:t}),s}async recordContextEvents(t){let a=performance.now(),{cascadeId:n,functionId:e,updates:s}=t,c=Object.entries(s).map(([d,i])=>({key:d,value:this.sql.json(i),function_id:e,cascade_id:n,created_at:new Date}));if(c.length===0){let d=performance.now()-a;return console.log(`recordContextEvents latency: ${d.toFixed(2)}ms (no events)`,{cascadeId:n,functionId:e}),{status:"SUCCESS"}}await this.sql`
+      INSERT INTO context_events ${this.sql(c,"key","value","function_id","cascade_id","created_at")}
+    `;let o=performance.now()-a;return console.log(`recordContextEvents latency: ${o.toFixed(2)}ms (${c.length} events)`,{cascadeId:n,functionId:e}),{status:"SUCCESS"}}async hydrateCascadeContext(t,a){let n=performance.now(),e=await this.sql`
+      SELECT key, value, function_id, created_at
+      FROM context_events
+      WHERE cascade_id = ${t}
+        AND function_id < ${a}
+      ORDER BY function_id ASC, created_at ASC
+    `,s={};for(let o of e){let d=o.key,i=o.value;if(s[d]||(s[d]=[]),typeof i=="object"&&i!==null&&!Array.isArray(i)&&"index"in i){let _=i.index;s[d][_]=i}else s[d].push(i)}let c=performance.now()-n;return console.log(`hydrateCascadeContext latency: ${c.toFixed(2)}ms (${e.length} events)`,{cascadeId:t,upToFunctionId:a}),s}async forkCascade(t){let a=performance.now(),{sourceCascadeId:n,newCascadeId:e,upToFunctionId:s}=t;await this.sql.begin(async o=>{await o`
+        INSERT INTO cascades (id, user_id, status, fn_id, created_at, updated_at)
+        SELECT
+          ${e},
+          user_id,
+          'RUNNING',
+          ${s-1},
+          NOW(),
+          NOW()
+        FROM cascades
+        WHERE id = ${n}
+      `,await o`
+        INSERT INTO node_executions (
+          id,
+          node_instance_id,
+          cascade_id,
+          node_name,
+          function_id,
+          input_context,
+          location,
+          status,
+          started_at,
+          completed_at,
+          full_output,
+          error
+        )
+        SELECT
+          gen_random_uuid(),
+          node_instance_id,
+          ${e},
+          node_name,
+          function_id,
+          input_context,
+          location,
+          status,
+          started_at,
+          completed_at,
+          full_output,
+          error
+        FROM node_executions
+        WHERE cascade_id = ${n}
+          AND function_id < ${s}
+      `,await o`
+        INSERT INTO context_events (
+          key,
+          value,
+          function_id,
+          cascade_id,
+          created_at
+        )
+        SELECT
+          key,
+          value,
+          function_id,
+          ${e},
+          created_at
+        FROM context_events
+        WHERE cascade_id = ${n}
+          AND function_id < ${s}
+      `});let c=performance.now()-a;return console.log(`forkCascade latency: ${c.toFixed(2)}ms`,{sourceCascadeId:n,newCascadeId:e,upToFunctionId:s}),{newCascadeId:e,status:"SUCCESS"}}};0&&(module.exports={PostgresPersistor});

package/dist/index.d.cts

@@ -0,0 +1,40 @@
+import postgres from 'postgres';
+import { CascadePersistence, ClaimRequest, ClaimResponse, WorkflowContext } from '@cascaide-ts/core';
+export { CascadePersistence } from '@cascaide-ts/core';
+
+declare class PostgresPersistor implements CascadePersistence {
+    private sql;
+    constructor(sql: postgres.Sql<{}>);
+    claimNodeExecution(params: ClaimRequest): Promise<ClaimResponse>;
+    finalizeNodeExecution(params: {
+        nodeInstanceId: string;
+        cascadeId: string;
+        fullOutput: any;
+        hasSpawns: boolean;
+    }): Promise<{
+        status: string;
+    }>;
+    markExecutionFailed(nodeInstanceId: string, cascadeId: string, error: string): Promise<{
+        status: string;
+    }>;
+    recordContextEvents(params: {
+        cascadeId: string;
+        functionId: number;
+        updates: {
+            [key: string]: any;
+        };
+    }): Promise<{
+        status: string;
+    }>;
+    hydrateCascadeContext(cascadeId: string, upToFunctionId: number): Promise<WorkflowContext>;
+    forkCascade(params: {
+        sourceCascadeId: string;
+        newCascadeId: string;
+        upToFunctionId: number;
+    }): Promise<{
+        newCascadeId: string;
+        status: string;
+    }>;
+}
+
+export { PostgresPersistor };

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+import postgres from 'postgres';
+import { CascadePersistence, ClaimRequest, ClaimResponse, WorkflowContext } from '@cascaide-ts/core';
+export { CascadePersistence } from '@cascaide-ts/core';
+
+declare class PostgresPersistor implements CascadePersistence {
+    private sql;
+    constructor(sql: postgres.Sql<{}>);
+    claimNodeExecution(params: ClaimRequest): Promise<ClaimResponse>;
+    finalizeNodeExecution(params: {
+        nodeInstanceId: string;
+        cascadeId: string;
+        fullOutput: any;
+        hasSpawns: boolean;
+    }): Promise<{
+        status: string;
+    }>;
+    markExecutionFailed(nodeInstanceId: string, cascadeId: string, error: string): Promise<{
+        status: string;
+    }>;
+    recordContextEvents(params: {
+        cascadeId: string;
+        functionId: number;
+        updates: {
+            [key: string]: any;
+        };
+    }): Promise<{
+        status: string;
+    }>;
+    hydrateCascadeContext(cascadeId: string, upToFunctionId: number): Promise<WorkflowContext>;
+    forkCascade(params: {
+        sourceCascadeId: string;
+        newCascadeId: string;
+        upToFunctionId: number;
+    }): Promise<{
+        newCascadeId: string;
+        status: string;
+    }>;
+}
+
+export { PostgresPersistor };

package/dist/index.js

@@ -0,0 +1,136 @@
+import{randomUUID as m}from"crypto";var u=class{constructor(o){this.sql=o}async claimNodeExecution(o){let c=performance.now(),{nodeInstanceId:n,cascadeId:e,userId:t,nodeName:s,functionId:a,inputContext:d,location:i}=o;console.log("Claiming node execution:",{cascadeId:e,nodeName:s,requestedId:a});let r=m(),l=await this.sql.begin(async f=>{let _=await f`
+        WITH conflict_check AS (
+          -- Single aggregation combining conflict detection and MAX calculation
+          -- More efficient than separate EXISTS and MAX queries
+          SELECT 
+            CASE 
+              WHEN COUNT(*) FILTER (WHERE function_id = ${a}) > 0 
+              THEN MAX(function_id) + 1
+              ELSE ${a}
+            END as next_fn_id
+          FROM node_executions 
+          WHERE cascade_id = ${e}
+        ),
+        cascade_upsert AS (
+          INSERT INTO cascades (id, user_id, status, fn_id, created_at, updated_at)
+          SELECT ${e}, ${t}, 'RUNNING', next_fn_id, NOW(), NOW()
+          FROM conflict_check
+          ON CONFLICT (id) DO UPDATE 
+            SET fn_id = EXCLUDED.fn_id, updated_at = NOW()
+          RETURNING fn_id
+        )
+        INSERT INTO node_executions (
+          id, 
+          node_instance_id, 
+          cascade_id, 
+          node_name, 
+          function_id, 
+          input_context, 
+          location, 
+          status, 
+          started_at
+        )
+        SELECT 
+          ${r}, 
+          ${n}, 
+          ${e}, 
+          ${s}, 
+          fn_id, 
+          ${this.sql.json(d)}, 
+          ${i}, 
+          'RUNNING', 
+          NOW()
+        FROM cascade_upsert
+        RETURNING status, function_id as "functionId"
+      `;return{status:_[0].status,functionId:Number(_[0].functionId)}}),E=performance.now()-c;return console.log(`claimNodeExecution latency: ${E.toFixed(2)}ms`,{cascadeId:e,nodeName:s}),l}async finalizeNodeExecution(o){let c=performance.now(),{nodeInstanceId:n,cascadeId:e,fullOutput:t,hasSpawns:s}=o,a=await this.sql.begin(async i=>(await i`
+        WITH updated_node AS (
+          UPDATE node_executions
+          SET 
+            status = 'COMPLETED',
+            full_output = ${this.sql.json(t)},
+            completed_at = NOW()
+          WHERE node_instance_id = ${n}
+          RETURNING cascade_id
+        )
+        UPDATE cascades
+        SET status = 'COMPLETED', updated_at = NOW()
+        WHERE id IN (SELECT cascade_id FROM updated_node)
+          AND ${!s}
+      `,{status:"COMPLETED"})),d=performance.now()-c;return console.log(`finalizeNodeExecution latency: ${d.toFixed(2)}ms`,{cascadeId:e,nodeInstanceId:n}),a}async markExecutionFailed(o,c,n){let e=performance.now(),t=await this.sql.begin(async a=>(await a`
+        WITH updated_node AS (
+          UPDATE node_executions
+          SET status = 'FAILED', error = ${n}, completed_at = NOW()
+          WHERE node_instance_id = ${o}
+          RETURNING cascade_id
+        )
+        UPDATE cascades
+        SET status = 'ERROR', updated_at = NOW()
+        WHERE id IN (SELECT cascade_id FROM updated_node)
+      `,{status:"FAILED"})),s=performance.now()-e;return console.log(`markExecutionFailed latency: ${s.toFixed(2)}ms`,{cascadeId:c,nodeInstanceId:o}),t}async recordContextEvents(o){let c=performance.now(),{cascadeId:n,functionId:e,updates:t}=o,s=Object.entries(t).map(([d,i])=>({key:d,value:this.sql.json(i),function_id:e,cascade_id:n,created_at:new Date}));if(s.length===0){let d=performance.now()-c;return console.log(`recordContextEvents latency: ${d.toFixed(2)}ms (no events)`,{cascadeId:n,functionId:e}),{status:"SUCCESS"}}await this.sql`
+      INSERT INTO context_events ${this.sql(s,"key","value","function_id","cascade_id","created_at")}
+    `;let a=performance.now()-c;return console.log(`recordContextEvents latency: ${a.toFixed(2)}ms (${s.length} events)`,{cascadeId:n,functionId:e}),{status:"SUCCESS"}}async hydrateCascadeContext(o,c){let n=performance.now(),e=await this.sql`
+      SELECT key, value, function_id, created_at
+      FROM context_events
+      WHERE cascade_id = ${o}
+        AND function_id < ${c}
+      ORDER BY function_id ASC, created_at ASC
+    `,t={};for(let a of e){let d=a.key,i=a.value;if(t[d]||(t[d]=[]),typeof i=="object"&&i!==null&&!Array.isArray(i)&&"index"in i){let r=i.index;t[d][r]=i}else t[d].push(i)}let s=performance.now()-n;return console.log(`hydrateCascadeContext latency: ${s.toFixed(2)}ms (${e.length} events)`,{cascadeId:o,upToFunctionId:c}),t}async forkCascade(o){let c=performance.now(),{sourceCascadeId:n,newCascadeId:e,upToFunctionId:t}=o;await this.sql.begin(async a=>{await a`
+        INSERT INTO cascades (id, user_id, status, fn_id, created_at, updated_at)
+        SELECT
+          ${e},
+          user_id,
+          'RUNNING',
+          ${t-1},
+          NOW(),
+          NOW()
+        FROM cascades
+        WHERE id = ${n}
+      `,await a`
+        INSERT INTO node_executions (
+          id,
+          node_instance_id,
+          cascade_id,
+          node_name,
+          function_id,
+          input_context,
+          location,
+          status,
+          started_at,
+          completed_at,
+          full_output,
+          error
+        )
+        SELECT
+          gen_random_uuid(),
+          node_instance_id,
+          ${e},
+          node_name,
+          function_id,
+          input_context,
+          location,
+          status,
+          started_at,
+          completed_at,
+          full_output,
+          error
+        FROM node_executions
+        WHERE cascade_id = ${n}
+          AND function_id < ${t}
+      `,await a`
+        INSERT INTO context_events (
+          key,
+          value,
+          function_id,
+          cascade_id,
+          created_at
+        )
+        SELECT
+          key,
+          value,
+          function_id,
+          ${e},
+          created_at
+        FROM context_events
+        WHERE cascade_id = ${n}
+          AND function_id < ${t}
+      `});let s=performance.now()-c;return console.log(`forkCascade latency: ${s.toFixed(2)}ms`,{sourceCascadeId:n,newCascadeId:e,upToFunctionId:t}),{newCascadeId:e,status:"SUCCESS"}}};export{u as PostgresPersistor};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@cascaide-ts/postgres-js",
+  "version": "0.1.0",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "postgres": "^3.4.0",
+    "@cascaide-ts/core": "0.1.0"
+  },
+  "devDependencies": {
+    "postgres": "^3.4.0",
+    "tsup": "^8.0.0",
+    "@cascaide-ts/core": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  }
+}