@powerhousedao/network-admin 0.0.61 → 0.0.62

package/dist/processors/factory.js

@@ -5,12 +5,12 @@
 import {} from "document-drive/processors/types";
 import {} from "document-model";
 // Import processor factories here as they are generated
-import { MyProcessorProcessorFactory } from "./my-processor/factory.js";
+import { workstreamsProcessorFactory } from "./workstreams/factory.js";
 export const processorFactory = (module) => {
     // Initialize all processor factories once with the module
     const factories = [];
     // Add processors here as they are generated
-    factories.push(MyProcessorProcessorFactory(module));
+    factories.push(workstreamsProcessorFactory(module));
     // Return the inner function that will be called for each drive
     return async (driveHeader) => {
         const processors = [];

package/dist/processors/index.d.ts

@@ -1,4 +1,5 @@
 export {};
 export { processorFactory } from "./factory.js";
-export { MyProcessorProcessor } from "./my-processor/index.js";
+export * as WorkstreamsProcessor from "./workstreams/index.js";
+export { workstreamsProcessorFactory } from "./workstreams/factory.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/processors/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../processors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,CAAC;AACX,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../processors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC;AACV,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,oBAAoB,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/processors/index.js

@@ -1,3 +1,4 @@
 export {};
 export { processorFactory } from "./factory.js";
-export { MyProcessorProcessor } from "./my-processor/index.js";
+export * as WorkstreamsProcessor from "./workstreams/index.js";
+export { workstreamsProcessorFactory } from "./workstreams/factory.js";

package/dist/processors/workstreams/factory.d.ts

@@ -0,0 +1,4 @@
+import { type ProcessorRecord, type IProcessorHostModule } from "document-drive";
+import { type PHDocumentHeader } from "document-model";
+export declare const workstreamsProcessorFactory: (module: IProcessorHostModule) => (driveHeader: PHDocumentHeader) => Promise<ProcessorRecord[]>;
+//# sourceMappingURL=factory.d.ts.map

package/dist/processors/workstreams/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../processors/workstreams/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,oBAAoB,EAC1B,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAGvD,eAAO,MAAM,2BAA2B,GACrC,QAAQ,oBAAoB,MACtB,aAAa,gBAAgB,KAAG,OAAO,CAAC,eAAe,EAAE,CAiC/D,CAAC"}

package/dist/processors/workstreams/factory.js

@@ -0,0 +1,28 @@
+import {} from "document-drive";
+import {} from "document-drive";
+import {} from "document-model";
+import { WorkstreamsProcessor } from "./index.js";
+export const workstreamsProcessorFactory = (module) => async (driveHeader) => {
+    // Create a namespace for the processor and the provided drive id
+    const namespace = WorkstreamsProcessor.getNamespace(driveHeader.id);
+    console.log(`[WorkstreamsProcessor] Factory called for drive: ${driveHeader.id}, namespace: ${namespace}`);
+    // Create a namespaced db for the processor
+    const store = await module.relationalDb.createNamespace(namespace);
+    // Create a filter for the processor
+    const filter = {
+        branch: ["main"],
+        documentId: ["*"],
+        documentType: ["powerhouse/workstream", "powerhouse/document-drive"],
+        scope: ["global"],
+    };
+    // Create the processor
+    const processor = new WorkstreamsProcessor(namespace, filter, store);
+    // Initialize database tables (run migrations)
+    await processor.initAndUpgrade();
+    return [
+        {
+            processor,
+            filter,
+        },
+    ];
+};

package/dist/processors/workstreams/index.d.ts

@@ -0,0 +1,16 @@
+import { RelationalDbProcessor } from "document-drive";
+import type { InternalTransmitterUpdate, InternalOperationUpdate } from "document-drive";
+import type { DB } from "./schema.js";
+export declare class WorkstreamsProcessor extends RelationalDbProcessor<DB> {
+    static getNamespace(driveId: string): string;
+    workstreams: string[];
+    initAndUpgrade(): Promise<void>;
+    onStrands(strands: InternalTransmitterUpdate[]): Promise<void>;
+    onDisconnect(): Promise<void>;
+    setWorkstream: (strand: InternalTransmitterUpdate) => Promise<void>;
+    updateInitialProposalInWorkstream: (strand: InternalTransmitterUpdate, operation: InternalOperationUpdate) => Promise<void>;
+    updateSowFromAlternativeProposal: (strand: InternalTransmitterUpdate, operation: InternalOperationUpdate) => Promise<void>;
+    updateNetworkInWorkstream: (strand: InternalTransmitterUpdate, operation: InternalOperationUpdate) => Promise<void>;
+    updateWorkstream: (strand: InternalTransmitterUpdate, operation: InternalOperationUpdate) => Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/processors/workstreams/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../processors/workstreams/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EACV,yBAAyB,EACzB,uBAAuB,EAExB,MAAM,gBAAgB,CAAC;AASxB,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AAEtC,qBAAa,oBAAqB,SAAQ,qBAAqB,CAAC,EAAE,CAAC;WACjD,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAKrD,WAAW,EAAE,MAAM,EAAE,CAAM;IAEZ,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAI/B,SAAS,CACtB,OAAO,EAAE,yBAAyB,EAAE,GACnC,OAAO,CAAC,IAAI,CAAC;IA0CV,YAAY;IAgBlB,aAAa,GAAU,QAAQ,yBAAyB,mBAuCtD;IAEF,iCAAiC,GAC/B,QAAQ,yBAAyB,EACjC,WAAW,uBAAuB,mBAiDlC;IAEF,gCAAgC,GAC9B,QAAQ,yBAAyB,EACjC,WAAW,uBAAuB,mBAsDlC;IAEF,yBAAyB,GACvB,QAAQ,yBAAyB,EACjC,WAAW,uBAAuB,mBAyClC;IAEF,gBAAgB,GACd,QAAQ,yBAAyB,EACjC,WAAW,uBAAuB,mBA0ClC;CACH"}

package/dist/processors/workstreams/index.js

@@ -0,0 +1,259 @@
+import { RelationalDbProcessor } from "document-drive";
+import { up } from "./migrations.js";
+export class WorkstreamsProcessor extends RelationalDbProcessor {
+    static getNamespace(driveId) {
+        // Default namespace: `${this.name}_${driveId.replaceAll("-", "_")}`
+        return super.getNamespace(driveId);
+    }
+    workstreams = [];
+    async initAndUpgrade() {
+        await up(this.relationalDb);
+    }
+    async onStrands(strands) {
+        if (strands.length === 0) {
+            return;
+        }
+        for (const strand of strands) {
+            if (strand.operations.length === 0) {
+                continue;
+            }
+            if (strand.documentType === "powerhouse/workstream") {
+                this.setWorkstream(strand);
+            }
+            // console.log("strand", { documentType: strand.documentType, docId: strand.documentId });
+            for (const operation of strand.operations) {
+                if (strand.documentType === "powerhouse/workstream") {
+                    this.updateWorkstream(strand, operation);
+                    this.updateNetworkInWorkstream(strand, operation);
+                    this.updateInitialProposalInWorkstream(strand, operation);
+                    this.updateSowFromAlternativeProposal(strand, operation);
+                }
+                if (strand.documentType === "powerhouse/document-drive") {
+                    if (operation.action.type === "DELETE_NODE") {
+                        const castAction = operation.action;
+                        console.log("deleting workstream node", castAction.input.id);
+                        const foundWorkstream = this.workstreams.find((ws) => ws === castAction.input.id);
+                        if (foundWorkstream) {
+                            await this.relationalDb
+                                .deleteFrom("workstreams")
+                                .where("workstream_phid", "=", foundWorkstream)
+                                .execute();
+                        }
+                    }
+                }
+            }
+        }
+    }
+    async onDisconnect() {
+        // Clean up all workstreams for this drive's namespace when the drive is deleted
+        // Since the database is already namespaced per drive, we delete all rows
+        // This ensures no orphaned data remains after drive deletion
+        try {
+            await this.relationalDb.deleteFrom("workstreams").execute();
+            console.log(`Cleaned up workstreams for namespace: ${this.namespace}`);
+        }
+        catch (error) {
+            console.error(`Error cleaning up workstreams for namespace ${this.namespace}:`, error);
+            // Don't throw - cleanup errors shouldn't prevent drive deletion
+        }
+    }
+    setWorkstream = async (strand) => {
+        const docId = strand.documentId;
+        const existingWorkstreamPhids = await this.relationalDb
+            .selectFrom("workstreams")
+            .select("workstream_phid")
+            .where("workstream_phid", "=", docId)
+            .execute();
+        if (existingWorkstreamPhids.length === 0) {
+            console.log("No workstream id found, inserting new one", docId);
+            this.workstreams.push(docId);
+            // insert network id
+            await this.relationalDb
+                .insertInto("workstreams")
+                .values({
+                network_phid: strand.state.client?.id ? strand.state.client.id : null,
+                network_slug: strand.state.client?.name
+                    ? strand.state.client.name.toLowerCase().split(" ").join("-")
+                    : null,
+                workstream_phid: strand.documentId,
+                workstream_slug: strand.state.title
+                    ? strand.state.title.toLowerCase().split(" ").join("-")
+                    : "",
+                workstream_title: strand.state.title,
+                workstream_status: strand.state.status,
+                sow_phid: strand.state.initialProposal
+                    ? strand.state.initialProposal.sow
+                    : null,
+                // final_milestone_target: new Date(),
+                initial_proposal_status: strand.state.initialProposal
+                    ? strand.state.initialProposal.status
+                    : null,
+                initial_proposal_author: strand.state.initialProposal
+                    ? strand.state.initialProposal.author.name
+                    : null,
+            })
+                .onConflict((oc) => oc.column("workstream_phid").doNothing())
+                .execute();
+        }
+    };
+    updateInitialProposalInWorkstream = async (strand, operation) => {
+        const docId = strand.documentId;
+        const existingWorkstreamPhids = await this.relationalDb
+            .selectFrom("workstreams")
+            .select("workstream_phid")
+            .where("workstream_phid", "=", docId)
+            .execute();
+        const [foundWorkstreamId] = existingWorkstreamPhids;
+        if (foundWorkstreamId) {
+            // update existing workstream row
+            if (operation.action.type === "EDIT_INITIAL_PROPOSAL") {
+                const input = operation.action.input;
+                if (!input)
+                    return;
+                console.log("updating initial proposal in workstream", operation.action.input);
+                // Build update object with only defined values
+                const updateData = {};
+                // Check for undefined, not truthiness - allows null to pass through
+                if (input.sowId !== undefined) {
+                    if (strand.state.initialProposal?.status === "ACCEPTED") {
+                        updateData.sow_phid = strand.state.initialProposal?.sow || null;
+                    }
+                }
+                if (input.proposalAuthor) {
+                    updateData.initial_proposal_author = input.proposalAuthor.name;
+                }
+                if (input.status) {
+                    updateData.initial_proposal_status = input.status;
+                    if (input.status === "ACCEPTED") {
+                        updateData.sow_phid = strand.state.initialProposal?.sow || null;
+                    }
+                }
+                // Only execute update if there are fields to update
+                if (Object.keys(updateData).length > 0) {
+                    await this.relationalDb
+                        .updateTable("workstreams")
+                        .set(updateData)
+                        .where("workstream_phid", "=", docId)
+                        .execute();
+                }
+            }
+        }
+    };
+    updateSowFromAlternativeProposal = async (strand, operation) => {
+        const docId = strand.documentId;
+        const existingWorkstreamPhids = await this.relationalDb
+            .selectFrom("workstreams")
+            .select("workstream_phid")
+            .where("workstream_phid", "=", docId)
+            .execute();
+        const [foundWorkstreamId] = existingWorkstreamPhids;
+        if (foundWorkstreamId) {
+            // update existing workstream row
+            if (operation.action.type === "EDIT_ALTERNATIVE_PROPOSAL") {
+                const input = operation.action.input;
+                if (!input)
+                    return;
+                console.log("updating sow from alternative proposal in workstream", operation.action.input);
+                // Build update object with only defined values
+                const updateData = {};
+                const selectedAlternativeProposal = strand.state.alternativeProposals.find((proposal) => proposal.id === input.id);
+                if (selectedAlternativeProposal) {
+                    // Check for undefined, not truthiness - allows null to pass through
+                    if (input.sowId !== undefined) {
+                        if (selectedAlternativeProposal.status === "ACCEPTED") {
+                            updateData.sow_phid = selectedAlternativeProposal.sow || null;
+                        }
+                    }
+                    if (input.status) {
+                        if (input.status === "ACCEPTED") {
+                            updateData.sow_phid = selectedAlternativeProposal.sow || null;
+                        }
+                    }
+                }
+                // Only execute update if there are fields to update
+                if (Object.keys(updateData).length > 0) {
+                    await this.relationalDb
+                        .updateTable("workstreams")
+                        .set(updateData)
+                        .where("workstream_phid", "=", docId)
+                        .execute();
+                }
+            }
+        }
+    };
+    updateNetworkInWorkstream = async (strand, operation) => {
+        const docId = strand.documentId;
+        const existingWorkstreamPhids = await this.relationalDb
+            .selectFrom("workstreams")
+            .select("workstream_phid")
+            .where("workstream_phid", "=", docId)
+            .execute();
+        const [foundWorkstreamId] = existingWorkstreamPhids;
+        if (foundWorkstreamId) {
+            // update existing workstream row
+            if (operation.action.type === "EDIT_CLIENT_INFO") {
+                const input = operation.action.input;
+                if (!input)
+                    return;
+                console.log("updating client in workstream", operation.action.input);
+                // Build update object with only defined values
+                const updateData = {};
+                if (input.clientId) {
+                    updateData.network_phid = input.clientId;
+                }
+                if (input.name) {
+                    updateData.network_slug = input.name
+                        .toLowerCase()
+                        .split(" ")
+                        .join("-");
+                }
+                // Only execute update if there are fields to update
+                if (Object.keys(updateData).length > 0) {
+                    await this.relationalDb
+                        .updateTable("workstreams")
+                        .set(updateData)
+                        .where("workstream_phid", "=", docId)
+                        .execute();
+                }
+            }
+        }
+    };
+    updateWorkstream = async (strand, operation) => {
+        const docId = strand.documentId;
+        const existingWorkstreamPhids = await this.relationalDb
+            .selectFrom("workstreams")
+            .select("workstream_phid")
+            .where("workstream_phid", "=", docId)
+            .execute();
+        const [foundWorkstreamId] = existingWorkstreamPhids;
+        if (foundWorkstreamId) {
+            // update existing workstream row
+            if (operation.action.type === "EDIT_WORKSTREAM") {
+                const input = operation.action.input;
+                if (!input)
+                    return;
+                console.log("updating workstream", operation.action.input);
+                // Build update object with only defined values
+                const updateData = {};
+                if (input.title) {
+                    updateData.workstream_title = input.title;
+                    updateData.workstream_slug = input.title
+                        .toLowerCase()
+                        .split(" ")
+                        .join("-");
+                }
+                if (input.status) {
+                    updateData.workstream_status = input.status;
+                }
+                // Only execute update if there are fields to update
+                if (Object.keys(updateData).length > 0) {
+                    await this.relationalDb
+                        .updateTable("workstreams")
+                        .set(updateData)
+                        .where("workstream_phid", "=", docId)
+                        .execute();
+                }
+            }
+        }
+    };
+}

package/dist/processors/workstreams/migrations.d.ts

@@ -0,0 +1,4 @@
+import { type IRelationalDb } from "document-drive";
+export declare function up(db: IRelationalDb<any>): Promise<void>;
+export declare function down(db: IRelationalDb<any>): Promise<void>;
+//# sourceMappingURL=migrations.d.ts.map

package/dist/processors/workstreams/migrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrations.d.ts","sourceRoot":"","sources":["../../../processors/workstreams/migrations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpD,wBAAsB,EAAE,CAAC,EAAE,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAuB9D;AAED,wBAAsB,IAAI,CAAC,EAAE,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAGhE"}

package/dist/processors/workstreams/migrations.js

@@ -0,0 +1,30 @@
+import {} from "document-drive";
+export async function up(db) {
+    // Create table with IF NOT EXISTS
+    try {
+        await db.schema
+            .createTable("workstreams")
+            .addColumn("network_phid", "varchar(255)")
+            .addColumn("network_slug", "varchar(255)")
+            .addColumn("workstream_phid", "varchar(255)")
+            .addColumn("workstream_slug", "varchar(255)")
+            .addColumn("workstream_title", "varchar(255)")
+            .addColumn("workstream_status", "varchar(255)")
+            .addColumn("sow_phid", "varchar(255)")
+            .addColumn("final_milestone_target", "timestamp")
+            .addColumn("initial_proposal_status", "varchar(255)")
+            .addColumn("initial_proposal_author", "varchar(255)")
+            .addPrimaryKeyConstraint("workstreams_pkey", ["workstream_phid"])
+            .ifNotExists()
+            .execute();
+        console.log("[WorkstreamsProcessor] Table 'workstreams' created or already exists");
+    }
+    catch (error) {
+        console.error("[WorkstreamsProcessor] Failed to create 'workstreams' table:", error);
+        throw error;
+    }
+}
+export async function down(db) {
+    // drop table
+    await db.schema.dropTable("workstreams").execute();
+}

package/dist/processors/workstreams/schema.d.ts

@@ -0,0 +1,19 @@
+import type { ColumnType } from "kysely";
+export type Timestamp = ColumnType<Date, Date | string, Date | string>;
+export interface Workstreams {
+    final_milestone_target: Timestamp | null;
+    initial_proposal_author: string | null;
+    initial_proposal_status: string | null;
+    network_phid: string | null;
+    network_slug: string | null;
+    roadmap_oid: string | null;
+    sow_phid: string | null;
+    workstream_phid: string;
+    workstream_slug: string | null;
+    workstream_status: string | null;
+    workstream_title: string | null;
+}
+export interface DB {
+    workstreams: Workstreams;
+}
+//# sourceMappingURL=schema.d.ts.map

package/dist/processors/workstreams/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../processors/workstreams/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAEzC,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,EAAE,IAAI,GAAG,MAAM,CAAC,CAAC;AAEvE,MAAM,WAAW,WAAW;IAC1B,sBAAsB,EAAE,SAAS,GAAG,IAAI,CAAC;IACzC,uBAAuB,EAAE,MAAM,GAAG,IAAI,CAAC;IACvC,uBAAuB,EAAE,MAAM,GAAG,IAAI,CAAC;IACvC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,EAAE;IACjB,WAAW,EAAE,WAAW,CAAC;CAC1B"}

package/dist/processors/workstreams/schema.js

@@ -0,0 +1 @@
+export {};

package/dist/subgraphs/workstreams/resolvers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolvers.d.ts","sourceRoot":"","sources":["../../../subgraphs/workstreams/resolvers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAqC5D,eAAO,MAAM,YAAY,GAAI,UAAU,SAAS,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAk8BxE,CAAC"}
+{"version":3,"file":"resolvers.d.ts","sourceRoot":"","sources":["../../../subgraphs/workstreams/resolvers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAuC5D,eAAO,MAAM,YAAY,GAAI,UAAU,SAAS,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAi9BxE,CAAC"}

package/dist/subgraphs/workstreams/resolvers.js

@@ -1,7 +1,8 @@
 import {} from "@powerhousedao/reactor-api";
+import { WorkstreamsProcessor } from "../../processors/workstreams/index.js";
 import {} from "../../document-models/request-for-proposals/index.js";
 import {} from "../../document-models/workstream/index.js";
-import { AnalyticsPath } from "@powerhousedao/analytics-engine-core";
+import { sql } from "kysely";
 export const getResolvers = (subgraph) => {
     const reactor = subgraph.reactor;
     const db = subgraph.relationalDb;
@@ -23,11 +24,19 @@ export const getResolvers = (subgraph) => {
         }
         return null;
     };
+    // Normalize drive IDs to match the format used by the processor factory
+    // reactor.getDrives() returns base64-like IDs (with + and =)
+    // but driveHeader.id in the factory uses - instead of +
+    // TODO: Report this inconsistency to @powerhousedao packages
+    const normalizeDriveId = (driveId) => {
+        return driveId.replace(/\+/g, "-").replace(/=+$/, "");
+    };
     const getCandidateDrives = async () => {
         try {
             const drives = await reactor.getDrives?.();
-            if (Array.isArray(drives) && drives.length > 0)
-                return drives;
+            if (Array.isArray(drives) && drives.length > 0) {
+                return drives.map(normalizeDriveId);
+            }
         }
         catch { }
         return [];
@@ -256,153 +265,126 @@ export const getResolvers = (subgraph) => {
             };
         }
     };
-    const getWorkstreamRowsFromAnalytics = async (analyticsStore, filters, wantedSlug) => {
-        const select = {
-            network: [],
-            network_slug: [],
-            workstream_slug: [],
-            workstream_title: [],
-            status: [],
-            initial_proposal_status: [],
-            initial_proposal_author: [],
-            sow_phid: [],
-            workstream_phid: [],
-            operation_index: [],
-        };
-        if (filters) {
-            if ("workstreamId" in filters && filters.workstreamId) {
-                select.workstream_phid = [
-                    AnalyticsPath.fromString(`/${filters.workstreamId}`),
-                ];
-            }
-            if ("workstreamSlug" in filters && filters.workstreamSlug) {
-                select.workstream_slug = [
-                    AnalyticsPath.fromString(`/${filters.workstreamSlug}`),
-                ];
-            }
-            if (filters.networkId) {
-                select.network = [AnalyticsPath.fromString(`/${filters.networkId}`)];
-            }
-            if (filters.networkSlug) {
-                select.network_slug = [
-                    AnalyticsPath.fromString(`/${filters.networkSlug}`),
-                ];
-            }
-            else if ("networkName" in filters &&
-                filters.networkName &&
-                wantedSlug) {
-                select.network_slug = [AnalyticsPath.fromString(`/${wantedSlug}`)];
-            }
-            if ("networkNames" in filters && filters.networkNames) {
-                const networkSlugs = filters.networkNames
-                    .filter((name) => Boolean(name))
-                    .map((name) => deriveSlug(name));
-                if (networkSlugs.length > 0) {
-                    select.network_slug = networkSlugs.map((slug) => AnalyticsPath.fromString(`/${slug}`));
-                }
-            }
-            const statuses = (filters.workstreamStatuses || []).filter((status) => Boolean(status));
-            if (statuses.length > 0) {
-                select.status = statuses.map((s) => AnalyticsPath.fromString(`/${s}`));
-            }
-            else if (filters.workstreamStatus) {
-                select.status = [
-                    AnalyticsPath.fromString(`/${filters.workstreamStatus}`),
-                ];
-            }
+    const applyWorkstreamFilters = (qb, filters, wantedSlug) => {
+        // Handle workstreamId and workstreamSlug (from WorkstreamFilter)
+        if ("workstreamId" in filters && filters.workstreamId) {
+            qb = qb.where("workstream_phid", "=", filters.workstreamId);
         }
-        const series = await analyticsStore.getMatchingSeries({
-            start: null,
-            end: null,
-            metrics: ["Workstream"],
-            select,
-        });
-        const latestByWorkstream = {};
-        for (const s of series) {
-            const dims = s.dimensions;
-            const getPathString = (dim) => {
-                if (!dim)
-                    return null;
-                const path = dim.path?.toString() || dim.toString();
-                if (path === "?" || path === "none" || path === "/none" || path === "")
-                    return null;
-                return path.startsWith("/") ? path.substring(1) : path;
-            };
-            const workstreamPhid = getPathString(dims.workstream_phid) || s.source.toString().split("/")[3];
-            if (!workstreamPhid || workstreamPhid === "?")
-                continue;
-            const opIndex = parseInt(getPathString(dims.operation_index) || "0");
-            const existing = latestByWorkstream[workstreamPhid];
-            // Priority 1: Higher operation index
-            // Priority 2: Higher database record ID (if opIndex/timestamp are same)
-            if (!existing ||
-                opIndex > existing.opIndex ||
-                (opIndex === existing.opIndex && s.start.toMillis() >= existing.start.toMillis())) {
-                latestByWorkstream[workstreamPhid] = {
-                    network_phid: getPathString(dims.network),
-                    network_slug: getPathString(dims.network_slug),
-                    workstream_phid: workstreamPhid,
-                    workstream_slug: getPathString(dims.workstream_slug),
-                    workstream_title: getPathString(dims.workstream_title)?.replace(/-/g, "/"),
-                    workstream_status: getPathString(dims.status),
-                    sow_phid: getPathString(dims.sow_phid),
-                    initial_proposal_status: getPathString(dims.initial_proposal_status),
-                    initial_proposal_author: getPathString(dims.initial_proposal_author),
-                    start: s.start,
-                    opIndex,
-                };
+        else if ("workstreamSlug" in filters && filters.workstreamSlug) {
+            qb = qb.where("workstream_slug", "=", filters.workstreamSlug);
+        }
+        // Handle workstreamTitle filter (from WorkstreamsFilter)
+        if ("workstreamTitle" in filters && filters.workstreamTitle) {
+            // Use case-insensitive partial match for workstream title
+            // Filter out NULL values and do case-insensitive search
+            const searchPattern = `%${filters.workstreamTitle.toLowerCase()}%`;
+            qb = qb
+                .where("workstream_title", "is not", null)
+                .where((eb) => eb(sql `LOWER(workstream_title)`, "like", searchPattern));
+        }
+        if (filters.networkId) {
+            qb = qb.where("network_phid", "=", filters.networkId);
+        }
+        else if (filters.networkSlug) {
+            qb = qb.where("network_slug", "=", filters.networkSlug);
+        }
+        else if (filters.networkName && wantedSlug) {
+            qb = qb.where("network_slug", "=", wantedSlug);
+        }
+        else if ("networkNames" in filters && filters.networkNames) {
+            // Handle networkNames filter (from WorkstreamsFilter)
+            const networkSlugs = filters.networkNames
+                .filter((name) => Boolean(name))
+                .map((name) => deriveSlug(name));
+            if (networkSlugs.length > 0) {
+                qb = qb.where("network_slug", "in", networkSlugs);
             }
         }
-        let rows = Object.values(latestByWorkstream);
-        // Manual filtering for workstreamTitle (was partial match in SQL)
-        if (filters && "workstreamTitle" in filters && filters.workstreamTitle) {
-            const search = filters.workstreamTitle.toLowerCase();
-            rows = rows.filter((r) => r.workstream_title?.toLowerCase().includes(search));
+        const statuses = (filters.workstreamStatuses || []).filter((status) => Boolean(status));
+        if (statuses.length > 0) {
+            qb = qb.where("workstream_status", "in", statuses);
+        }
+        else if (filters.workstreamStatus) {
+            qb = qb.where("workstream_status", "=", filters.workstreamStatus);
+        }
+        return qb;
+    };
+    const applyScopeOfWorkFilters = (qb, filters, wantedSlug) => {
+        if (filters.workstreamId) {
+            qb = qb.where("workstream_phid", "=", filters.workstreamId);
+        }
+        else if (filters.workstreamSlug) {
+            qb = qb.where("workstream_slug", "=", filters.workstreamSlug);
+        }
+        if (filters.networkId) {
+            qb = qb.where("network_phid", "=", filters.networkId);
+        }
+        else if (filters.networkSlug) {
+            qb = qb.where("network_slug", "=", filters.networkSlug);
+        }
+        else if (filters.networkName && wantedSlug) {
+            qb = qb.where("network_slug", "=", wantedSlug);
+        }
+        if (filters.workstreamStatus) {
+            qb = qb.where("workstream_status", "=", filters.workstreamStatus);
         }
-        return rows;
+        return qb;
     };
     return {
         Query: {
             processorWorkstreams: async () => {
-                const analyticsStore = subgraph.analyticsStore;
-                if (!analyticsStore) {
-                    console.error("analyticsStore not found in subgraph");
-                    return [];
-                }
-                try {
-                    const rows = await getWorkstreamRowsFromAnalytics(analyticsStore);
-                    return rows.map((row) => ({
-                        network_phid: row.network_phid,
-                        network_slug: row.network_slug,
-                        workstream_phid: row.workstream_phid,
-                        workstream_slug: row.workstream_slug,
-                        workstream_title: row.workstream_title,
-                        workstream_status: row.workstream_status,
-                        sow_phid: row.sow_phid,
-                        roadmap_oid: null,
-                        final_milestone_target: null,
-                        initial_proposal_status: row.initial_proposal_status,
-                        initial_proposal_author: row.initial_proposal_author,
-                    }));
-                }
-                catch (error) {
-                    console.error("Error in processorWorkstreams resolver:", error);
-                    throw error;
-                }
+                const drives = await getCandidateDrives();
+                const allProcessorWorkstreams = await Promise.all(drives.map(async (driveId) => {
+                    const namespace = WorkstreamsProcessor.getNamespace(driveId);
+                    console.log(`[WorkstreamsProcessor] Resolver querying drive: ${driveId}, namespace: ${namespace}`);
+                    try {
+                        return await WorkstreamsProcessor.query(driveId, db)
+                            .selectFrom("workstreams")
+                            .selectAll()
+                            .execute();
+                    }
+                    catch (error) {
+                        console.warn(`[WorkstreamsProcessor] Failed to query namespace ${namespace}:`, error);
+                        return []; // Return empty array if table doesn't exist for this drive
+                    }
+                }));
+                // Flatten the array of arrays into a single array
+                const flattenedWorkstreams = allProcessorWorkstreams.flat();
+                return flattenedWorkstreams.map((workstream) => ({
+                    network_phid: workstream.network_phid,
+                    network_slug: workstream.network_slug,
+                    workstream_phid: workstream.workstream_phid,
+                    workstream_slug: workstream.workstream_slug,
+                    workstream_title: workstream.workstream_title,
+                    workstream_status: workstream.workstream_status,
+                    sow_phid: workstream.sow_phid,
+                    roadmap_oid: workstream.roadmap_oid,
+                    final_milestone_target: workstream.final_milestone_target,
+                    initial_proposal_status: workstream.initial_proposal_status,
+                    initial_proposal_author: workstream.initial_proposal_author,
+                }));
             },
             workstream: async (parent, args) => {
                 const filters = args.filter || {};
-                const analyticsStore = subgraph.analyticsStore;
-                if (!analyticsStore)
-                    return [];
+                const candidateDrives = await getCandidateDrives();
                 const wantedSlug = filters.networkSlug ||
                     (filters.networkName ? deriveSlug(filters.networkName) : undefined);
-                const rows = await getWorkstreamRowsFromAnalytics(analyticsStore, filters, wantedSlug);
                 const resolved = [];
                 const contributorPhids = new Set();
-                for (const row of rows) {
-                    const hydrated = await hydrateWorkstreamRow(row);
-                    resolved.push(hydrated);
+                for (const driveId of candidateDrives) {
+                    let qb = WorkstreamsProcessor.query(driveId, db)
+                        .selectFrom("workstreams")
+                        .selectAll();
+                    qb = applyWorkstreamFilters(qb, filters, wantedSlug);
+                    const rows = await qb.execute();
+                    if (rows.length === 0) {
+                        continue;
+                    }
+                    for (const row of rows) {
+                        const hydrated = await hydrateWorkstreamRow(row);
+                        resolved.push(hydrated);
+                    }
+                    break;
                 }
                 // Collect SOWs and their contributors
                 const sowDocs = collectSowsFromWorkstreams(resolved);
@@ -482,17 +464,35 @@ export const getResolvers = (subgraph) => {
             },
             workstreams: async (parent, args) => {
                 const filters = args.filter || {};
-                const analyticsStore = subgraph.analyticsStore;
-                if (!analyticsStore)
-                    return [];
+                const candidateDrives = await getCandidateDrives();
+                // Check if any filters are provided
+                const hasFilters = filters.networkId ||
+                    filters.networkSlug ||
+                    filters.networkName ||
+                    (filters.networkNames && filters.networkNames.length > 0) ||
+                    filters.workstreamTitle ||
+                    filters.workstreamStatus ||
+                    (filters.workstreamStatuses && filters.workstreamStatuses.length > 0);
                 const wantedSlug = filters.networkSlug ||
                     (filters.networkName ? deriveSlug(filters.networkName) : undefined);
-                const rows = await getWorkstreamRowsFromAnalytics(analyticsStore, filters, wantedSlug);
                 const results = [];
                 const contributorPhids = new Set();
-                for (const row of rows) {
-                    const hydrated = await hydrateWorkstreamRow(row);
-                    results.push(hydrated);
+                for (const driveId of candidateDrives) {
+                    let qb = WorkstreamsProcessor.query(driveId, db)
+                        .selectFrom("workstreams")
+                        .selectAll();
+                    // Only apply filters if any are provided
+                    if (hasFilters) {
+                        qb = applyWorkstreamFilters(qb, filters, wantedSlug);
+                    }
+                    const rows = await qb.execute();
+                    if (rows.length === 0) {
+                        continue;
+                    }
+                    for (const row of rows) {
+                        const hydrated = await hydrateWorkstreamRow(row);
+                        results.push(hydrated);
+                    }
                 }
                 // Collect SOWs and their contributors
                 const sowDocs = collectSowsFromWorkstreams(results);
@@ -572,109 +572,129 @@ export const getResolvers = (subgraph) => {
             },
             rfpByWorkstream: async (parent, args) => {
                 const filters = args.filter || {};
-                const analyticsStore = subgraph.analyticsStore;
-                if (!analyticsStore)
-                    return [];
+                const candidateDrives = await getCandidateDrives();
                 const wantedSlug = filters.networkSlug ||
                     (filters.networkName ? deriveSlug(filters.networkName) : undefined);
-                const rows = await getWorkstreamRowsFromAnalytics(analyticsStore, filters, wantedSlug);
                 const results = [];
-                for (const row of rows) {
-                    const hydrated = await hydrateWorkstreamRow(row);
-                    results.push({
-                        code: hydrated.code,
-                        title: hydrated.title,
-                        status: hydrated.status,
-                        rfp: hydrated.rfp,
-                    });
+                for (const driveId of candidateDrives) {
+                    let qb = WorkstreamsProcessor.query(driveId, db)
+                        .selectFrom("workstreams")
+                        .selectAll();
+                    qb = applyWorkstreamFilters(qb, filters, wantedSlug);
+                    const rows = await qb.execute();
+                    if (rows.length === 0) {
+                        continue;
+                    }
+                    for (const row of rows) {
+                        const hydrated = await hydrateWorkstreamRow(row);
+                        results.push({
+                            code: hydrated.code,
+                            title: hydrated.title,
+                            status: hydrated.status,
+                            rfp: hydrated.rfp,
+                        });
+                    }
+                    if (filters.workstreamId || filters.workstreamSlug) {
+                        break;
+                    }
                 }
                 return results;
             },
             scopeOfWorkByNetworkOrStatus: async (parent, args) => {
                 const filters = args.filter || {};
-                const analyticsStore = subgraph.analyticsStore;
-                if (!analyticsStore)
-                    return [];
+                const candidateDrives = await getCandidateDrives();
                 const wantedSlug = filters.networkSlug ||
                     (filters.networkName ? deriveSlug(filters.networkName) : undefined);
-                const rows = await getWorkstreamRowsFromAnalytics(analyticsStore, filters, wantedSlug);
                 const results = [];
                 const contributorPhids = new Set();
-                for (const row of rows) {
-                    const hydrated = await hydrateWorkstreamRow(row);
-                    // Collect SOWs based on proposalRole filter
-                    const sowDocs = [];
-                    if (!filters.proposalRole) {
-                        // If no proposalRole specified, include all SOWs
-                        if (hydrated.sow) {
-                            sowDocs.push(hydrated.sow);
-                        }
-                        if (hydrated.initialProposal?.sow) {
-                            sowDocs.push(hydrated.initialProposal.sow);
-                        }
-                        for (const altProposal of hydrated.alternativeProposals || []) {
-                            if (altProposal.sow) {
-                                sowDocs.push(altProposal.sow);
-                            }
-                        }
+                for (const driveId of candidateDrives) {
+                    let qb = WorkstreamsProcessor.query(driveId, db)
+                        .selectFrom("workstreams")
+                        .selectAll();
+                    qb = applyScopeOfWorkFilters(qb, filters, wantedSlug);
+                    const rows = await qb.execute();
+                    if (rows.length === 0) {
+                        continue;
                     }
-                    else if (filters.proposalRole === "INITIAL") {
-                        if (hydrated.initialProposal?.sow) {
-                            sowDocs.push(hydrated.initialProposal.sow);
+                    for (const row of rows) {
+                        const hydrated = await hydrateWorkstreamRow(row);
+                        // Collect SOWs based on proposalRole filter
+                        const sowDocs = [];
+                        if (!filters.proposalRole) {
+                            // If no proposalRole specified, include all SOWs
+                            if (hydrated.sow) {
+                                sowDocs.push(hydrated.sow);
+                            }
+                            if (hydrated.initialProposal?.sow) {
+                                sowDocs.push(hydrated.initialProposal.sow);
+                            }
+                            for (const altProposal of hydrated.alternativeProposals || []) {
+                                if (altProposal.sow) {
+                                    sowDocs.push(altProposal.sow);
+                                }
+                            }
                         }
-                    }
-                    else if (filters.proposalRole === "ALTERNATIVE") {
-                        for (const altProposal of hydrated.alternativeProposals || []) {
-                            if (altProposal.sow) {
-                                sowDocs.push(altProposal.sow);
+                        else if (filters.proposalRole === "INITIAL") {
+                            if (hydrated.initialProposal?.sow) {
+                                sowDocs.push(hydrated.initialProposal.sow);
                             }
                         }
-                    }
-                    else if (filters.proposalRole === "AWARDED") {
-                        // For AWARDED, we check if the workstream status is AWARDED
-                        // and return the initial proposal's SOW (as it's typically the awarded one)
-                        if (hydrated.status === "AWARDED" &&
-                            hydrated.initialProposal?.sow) {
-                            sowDocs.push(hydrated.initialProposal.sow);
+                        else if (filters.proposalRole === "ALTERNATIVE") {
+                            for (const altProposal of hydrated.alternativeProposals || []) {
+                                if (altProposal.sow) {
+                                    sowDocs.push(altProposal.sow);
+                                }
+                            }
                         }
-                    }
-                    // Collect contributor PHIDs from all SOWs
-                    for (const sow of sowDocs) {
-                        if (!sow || typeof sow !== "object")
-                            continue;
-                        if (Array.isArray(sow.contributors)) {
-                            sow.contributors.forEach((contributor) => {
-                                const phid = extractPhid(contributor);
-                                if (phid)
-                                    contributorPhids.add(phid);
-                            });
+                        else if (filters.proposalRole === "AWARDED") {
+                            // For AWARDED, we check if the workstream status is AWARDED
+                            // and return the initial proposal's SOW (as it's typically the awarded one)
+                            if (hydrated.status === "AWARDED" &&
+                                hydrated.initialProposal?.sow) {
+                                sowDocs.push(hydrated.initialProposal.sow);
+                            }
                         }
-                        // Collect deliverable owners too so `SOW_Deliverable.owner` can resolve
-                        if (Array.isArray(sow.deliverables)) {
-                            sow.deliverables.forEach((deliverable) => {
-                                if (!deliverable || typeof deliverable !== "object")
-                                    return;
-                                const phid = extractPhid(deliverable.owner);
-                                if (phid)
-                                    contributorPhids.add(phid);
-                            });
+                        // Collect contributor PHIDs from all SOWs
+                        for (const sow of sowDocs) {
+                            if (!sow || typeof sow !== "object")
+                                continue;
+                            if (Array.isArray(sow.contributors)) {
+                                sow.contributors.forEach((contributor) => {
+                                    const phid = extractPhid(contributor);
+                                    if (phid)
+                                        contributorPhids.add(phid);
+                                });
+                            }
+                            // Collect deliverable owners too so `SOW_Deliverable.owner` can resolve
+                            if (Array.isArray(sow.deliverables)) {
+                                sow.deliverables.forEach((deliverable) => {
+                                    if (!deliverable || typeof deliverable !== "object")
+                                        return;
+                                    const phid = extractPhid(deliverable.owner);
+                                    if (phid)
+                                        contributorPhids.add(phid);
+                                });
+                            }
+                            // Collect project owners too so `SOW_Project.projectOwner` can resolve
+                            if (Array.isArray(sow.projects)) {
+                                sow.projects.forEach((project) => {
+                                    if (!project || typeof project !== "object")
+                                        return;
+                                    const phid = extractPhid(project.projectOwner);
+                                    if (phid)
+                                        contributorPhids.add(phid);
+                                });
+                            }
                         }
-                        // Collect project owners too so `SOW_Project.projectOwner` can resolve
-                        if (Array.isArray(sow.projects)) {
-                            sow.projects.forEach((project) => {
-                                if (!project || typeof project !== "object")
-                                    return;
-                                const phid = extractPhid(project.projectOwner);
-                                if (phid)
-                                    contributorPhids.add(phid);
-                            });
+                        // Filter out null/undefined SOWs and add to results
+                        for (const sow of sowDocs) {
+                            if (sow) {
+                                results.push(sow);
+                            }
                         }
                     }
-                    // Filter out null/undefined SOWs and add to results
-                    for (const sow of sowDocs) {
-                        if (sow) {
-                            results.push(sow);
-                        }
+                    if (filters.workstreamId || filters.workstreamSlug) {
+                        break;
                     }
                 }
                 // Fetch all builder profile documents for contributors

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@powerhousedao/network-admin",
   "description": "Network Admin package for Powerhouse",
-  "version": "0.0.61",
+  "version": "0.0.62",
   "license": "AGPL-3.0-only",
   "type": "module",
   "files": [

package/dist/processors/my-processor/factory.d.ts

@@ -1,5 +0,0 @@
-import { type ProcessorRecord } from "document-drive";
-import { type IProcessorHostModule } from "document-drive";
-import { type PHDocumentHeader } from "document-model";
-export declare const MyProcessorProcessorFactory: (module: IProcessorHostModule) => (driveHeader: PHDocumentHeader) => ProcessorRecord[];
-//# sourceMappingURL=factory.d.ts.map

package/dist/processors/my-processor/factory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../processors/my-processor/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAGvD,eAAO,MAAM,2BAA2B,GACrC,QAAQ,oBAAoB,MAC5B,aAAa,gBAAgB,KAAG,eAAe,EAY/C,CAAC"}

package/dist/processors/my-processor/factory.js

@@ -1,17 +0,0 @@
-import {} from "document-drive";
-import {} from "document-drive";
-import {} from "document-model";
-import { MyProcessorProcessor } from "./index.js";
-export const MyProcessorProcessorFactory = (module) => (driveHeader) => {
-    return [
-        {
-            processor: new MyProcessorProcessor(module.analyticsStore),
-            filter: {
-                branch: ["main"],
-                documentId: ["*"],
-                scope: ["*"],
-                documentType: ["powerhouse/workstream"],
-            },
-        },
-    ];
-};

package/dist/processors/my-processor/index.d.ts

@@ -1,13 +0,0 @@
-import type { IAnalyticsStore } from "@powerhousedao/analytics-engine-core";
-import type { InternalTransmitterUpdate, IProcessor } from "document-drive";
-export declare class MyProcessorProcessor implements IProcessor {
-    private readonly analyticsStore;
-    private readonly NAMESPACE;
-    private readonly inputs;
-    constructor(analyticsStore: IAnalyticsStore);
-    onStrands(strands: InternalTransmitterUpdate[]): Promise<void>;
-    onDisconnect(): Promise<void>;
-    private addWorkstreamAnalytics;
-    private clearSource;
-}
-//# sourceMappingURL=index.d.ts.map

package/dist/processors/my-processor/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../processors/my-processor/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,eAAe,EAChB,MAAM,sCAAsC,CAAC;AAE9C,OAAO,KAAK,EAAE,yBAAyB,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAE5E,qBAAa,oBAAqB,YAAW,UAAU;IAKzC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAJ3C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAiB;IAE3C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;gBAExB,cAAc,EAAE,eAAe;IAItD,SAAS,CAAC,OAAO,EAAE,yBAAyB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAgD9D,YAAY;IAIlB,OAAO,CAAC,sBAAsB;YA+DhB,WAAW;CAO1B"}

package/dist/processors/my-processor/index.js

@@ -1,90 +0,0 @@
-import { DateTime } from "luxon";
-import { AnalyticsPath } from "@powerhousedao/analytics-engine-core";
-export class MyProcessorProcessor {
-    analyticsStore;
-    NAMESPACE = "MyProcessor";
-    inputs = [];
-    constructor(analyticsStore) {
-        this.analyticsStore = analyticsStore;
-        //
-    }
-    async onStrands(strands) {
-        if (strands.length === 0) {
-            return;
-        }
-        for (const strand of strands) {
-            if (strand.operations.length === 0) {
-                continue;
-            }
-            const source = AnalyticsPath.fromString(`/${this.NAMESPACE}/${strand.driveId}/${strand.documentId}/${strand.branch}/${strand.scope}`);
-            // clear source if we have already inserted these analytics
-            const firstOp = strand.operations[0];
-            if (firstOp.index === 0) {
-                await this.clearSource(source);
-            }
-            if (strand.documentType === "powerhouse/workstream") {
-                for (const operation of strand.operations) {
-                    const timestamp = operation.timestampUtcMs
-                        ? DateTime.fromMillis(parseInt(operation.timestampUtcMs))
-                        : DateTime.now();
-                    const state = operation.state || strand.state;
-                    // Record analytics for every operation to ensure we don't miss state changes
-                    this.addWorkstreamAnalytics(state, source, timestamp, strand.documentId, operation.index);
-                }
-            }
-        }
-        // batch insert
-        if (this.inputs.length > 0) {
-            await this.analyticsStore.addSeriesValues(this.inputs);
-            this.inputs.length = 0;
-        }
-    }
-    async onDisconnect() {
-        //
-    }
-    addWorkstreamAnalytics(state, source, timestamp, documentId, operationIndex) {
-        if (!state)
-            return;
-        const dimensions = {};
-        if (state.status) {
-            dimensions.status = AnalyticsPath.fromString(`/${state.status}`);
-        }
-        if (state.client?.id) {
-            dimensions.network = AnalyticsPath.fromString(`/${state.client.id}`);
-        }
-        const initialProposal = state.initialProposal;
-        if (initialProposal?.status) {
-            dimensions.initial_proposal_status = AnalyticsPath.fromString(`/${initialProposal.status}`);
-        }
-        if (state.client?.name) {
-            dimensions.network_slug = AnalyticsPath.fromString(`/${state.client.name.toLowerCase().split(" ").join("-")}`);
-        }
-        if (state.title) {
-            dimensions.workstream_slug = AnalyticsPath.fromString(`/${state.title.toLowerCase().split(" ").join("-")}`);
-            dimensions.workstream_title = AnalyticsPath.fromString(`/${state.title.split("/").join("-")}`);
-        }
-        if (initialProposal?.author?.id) {
-            dimensions.initial_proposal_author = AnalyticsPath.fromString(`/${initialProposal.author.id}`);
-        }
-        if (initialProposal?.sow) {
-            dimensions.sow_phid = AnalyticsPath.fromString(`/${initialProposal.sow}`);
-        }
-        dimensions.workstream_phid = AnalyticsPath.fromString(`/${documentId}`);
-        dimensions.operation_index = AnalyticsPath.fromString(`/${operationIndex}`);
-        this.inputs.push({
-            start: timestamp,
-            source,
-            metric: "workstream",
-            value: 1,
-            dimensions,
-        });
-    }
-    async clearSource(source) {
-        try {
-            await this.analyticsStore.clearSeriesBySource(source, true);
-        }
-        catch (e) {
-            console.error(e);
-        }
-    }
-}