@powerhousedao/vetra-builder-package 0.0.17 → 0.0.18

package/dist/processors/old_vetra-builder-relational-db-processor/index.js

@@ -0,0 +1,32 @@
+import { RelationalDbProcessor } from "document-drive/processors/relational";
+import { up } from "./migrations.js";
+export class VetraBuilderRelationalDbProcessorProcessor extends RelationalDbProcessor {
+    static getNamespace(driveId) {
+        // Default namespace: `${this.name}_${driveId.replaceAll("-", "_")}`
+        return super.getNamespace(driveId);
+    }
+    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;
+            }
+            for (const operation of strand.operations) {
+                await this.relationalDb
+                    .insertInto("todo")
+                    .values({
+                    task: `${strand.documentId}-${operation.index}: ${operation.action.type}`,
+                    status: true,
+                })
+                    .onConflict((oc) => oc.column("task").doNothing())
+                    .execute();
+            }
+        }
+    }
+    async onDisconnect() { }
+}

package/dist/processors/old_vetra-builder-relational-db-processor/migrations.d.ts

@@ -0,0 +1,3 @@
+import { type IRelationalDb } from "document-drive/processors/types";
+export declare function up(db: IRelationalDb<any>): Promise<void>;
+export declare function down(db: IRelationalDb<any>): Promise<void>;

package/dist/processors/old_vetra-builder-relational-db-processor/migrations.js

@@ -0,0 +1,14 @@
+export async function up(db) {
+    // Create table
+    await db.schema
+        .createTable("todo")
+        .addColumn("task", "varchar(255)")
+        .addColumn("status", "boolean")
+        .addPrimaryKeyConstraint("todo_pkey", ["task"])
+        .ifNotExists()
+        .execute();
+}
+export async function down(db) {
+    // drop table
+    await db.schema.dropTable("todo").execute();
+}

package/dist/processors/old_vetra-builder-relational-db-processor/schema.d.ts

@@ -0,0 +1,7 @@
+export interface Todo {
+    status: boolean | null;
+    task: string;
+}
+export interface DB {
+    todo: Todo;
+}

package/dist/processors/old_vetra-builder-relational-db-processor/schema.js

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

package/dist/processors/vetra-builder-relational-db-processor/builder-team-handlers.d.ts

@@ -0,0 +1,22 @@
+import type { DB } from "./schema.js";
+import type { IRelationalDb } from "document-drive";
+import { type BuilderTeamState, type BuilderTeamAction } from "document-models/builder-team/index.js";
+export declare class BuilderTeamHandlers {
+    private db;
+    private dbHelpers;
+    constructor(db: IRelationalDb<DB>);
+    handleBuilderTeamOperation(documentId: string, action: BuilderTeamAction, state: BuilderTeamState, driveId?: string): Promise<void>;
+    private handleSetLogo;
+    private handleSetProfileName;
+    private handleSetSlug;
+    private handleSetProfileDescription;
+    private handleUpdateSocials;
+    private handleAddMember;
+    private handleRemoveMember;
+    private handleAddSpace;
+    private handleDeleteSpace;
+    private handleUpdateSpaceInfo;
+    private handleAddPackage;
+    private handleUpdatePackageInfo;
+    private handleDeletePackage;
+}

package/dist/processors/vetra-builder-relational-db-processor/builder-team-handlers.js

@@ -0,0 +1,261 @@
+import { DatabaseHelpers } from "./database-helpers.js";
+export class BuilderTeamHandlers {
+    db;
+    dbHelpers;
+    constructor(db) {
+        this.db = db;
+        this.dbHelpers = new DatabaseHelpers(db);
+    }
+    async handleBuilderTeamOperation(documentId, action, state, driveId) {
+        switch (action.type) {
+            // Profile operations
+            case "SET_LOGO":
+                await this.handleSetLogo(documentId, action, state);
+                break;
+            case "SET_TEAM_NAME":
+                await this.handleSetProfileName(documentId, action, state);
+                break;
+            case "SET_SLUG":
+                await this.handleSetSlug(documentId, action, state);
+                break;
+            case "SET_DESCRIPTION":
+                await this.handleSetProfileDescription(documentId, action, state);
+                break;
+            case "SET_SOCIALS":
+                await this.handleUpdateSocials(documentId, action, state);
+                break;
+            // Members operations
+            case "ADD_MEMBER":
+                await this.handleAddMember(documentId, action, state);
+                break;
+            case "REMOVE_MEMBER":
+                await this.handleRemoveMember(documentId, action, state);
+                break;
+            // Spaces operations
+            case "ADD_SPACE":
+                await this.handleAddSpace(documentId, action, state);
+                break;
+            case "REMOVE_SPACE":
+                await this.handleDeleteSpace(documentId, action, state);
+                break;
+            case "UPDATE_SPACE_INFO":
+                await this.handleUpdateSpaceInfo(documentId, action, state);
+                break;
+            // case "REORDER_SPACES":
+            //   await this.handleReorderSpaces(documentId, action, state);
+            //   break;
+            // Packages operations
+            case "ADD_PACKAGE":
+                await this.handleAddPackage(documentId, action, state);
+                break;
+            case "REMOVE_PACKAGE":
+                await this.handleDeletePackage(documentId, action, state);
+                break;
+            case "UPDATE_PACKAGE_INFO":
+                await this.handleUpdatePackageInfo(documentId, action, state);
+                break;
+        }
+    }
+    // Profile operations
+    async handleSetLogo(documentId, action, state) {
+        await this.dbHelpers.ensureBuilderAccountExistsAndIsNotdeleted(documentId);
+        await this.dbHelpers.updateBuilderAccount(documentId, {
+            profile_logo: action.input.logo,
+        });
+    }
+    async handleSetProfileName(documentId, action, state) {
+        await this.dbHelpers.ensureBuilderAccountExistsAndIsNotdeleted(documentId);
+        await this.dbHelpers.updateBuilderAccount(documentId, {
+            profile_name: action.input.name,
+        });
+    }
+    async handleSetSlug(documentId, action, state) {
+        await this.dbHelpers.ensureBuilderAccountExistsAndIsNotdeleted(documentId);
+        await this.dbHelpers.updateBuilderAccount(documentId, {
+            profile_slug: action.input.slug,
+        });
+    }
+    async handleSetProfileDescription(documentId, action, state) {
+        await this.dbHelpers.ensureBuilderAccountExistsAndIsNotdeleted(documentId);
+        await this.dbHelpers.updateBuilderAccount(documentId, {
+            profile_description: action.input.description,
+        });
+    }
+    async handleUpdateSocials(documentId, action, state) {
+        await this.dbHelpers.ensureBuilderAccountExistsAndIsNotdeleted(documentId);
+        await this.dbHelpers.updateBuilderAccount(documentId, {
+            profile_socials_x: action.input.xProfile,
+            profile_socials_github: action.input.github,
+            profile_socials_website: action.input.website,
+        });
+    }
+    // Members operations
+    async handleAddMember(documentId, action, state) {
+        await this.dbHelpers.ensureBuilderAccountExistsAndIsNotdeleted(documentId);
+        if (!action.input.id)
+            return;
+        const memberExists = await this.dbHelpers.memberExists(documentId, action.input.id);
+        if (!memberExists) {
+            await this.db
+                .insertInto("builder_team_members")
+                .values({
+                id: action.input.id,
+                builder_team_id: documentId,
+                eth_address: "",
+                created_at: new Date(),
+            })
+                .execute();
+        }
+    }
+    async handleRemoveMember(documentId, action, state) {
+        if (!action.input.id)
+            return;
+        await this.db
+            .deleteFrom("builder_team_members")
+            .where("builder_team_id", "=", documentId)
+            .where("eth_address", "=", action.input.id)
+            .execute();
+    }
+    // Spaces operations
+    async handleAddSpace(documentId, action, state) {
+        await this.dbHelpers.ensureBuilderAccountExistsAndIsNotdeleted(documentId);
+        await this.db
+            .insertInto("builder_team_spaces")
+            .values({
+            id: action.input.id,
+            builder_team_id: documentId,
+            title: "",
+            description: "",
+            sort_order: 0,
+            created_at: new Date(),
+            updated_at: new Date(),
+        })
+            .onConflict((oc) => oc.column("id").doNothing())
+            .execute();
+    }
+    async handleDeleteSpace(documentId, action, state) {
+        await this.db
+            .deleteFrom("builder_team_spaces")
+            .where("id", "=", action.input.id)
+            .where("builder_team_id", "=", documentId)
+            .execute();
+    }
+    async handleUpdateSpaceInfo(documentId, action, state) {
+        const updates = {};
+        // Only include fields that are provided
+        if (action.input.title !== undefined) {
+            updates.title = action.input.title;
+        }
+        if (action.input.description !== undefined) {
+            updates.description = action.input.description;
+        }
+        // Only update if there are actual changes
+        if (Object.keys(updates).length > 0) {
+            await this.dbHelpers.updateBuilderSpace(action.input.id, documentId, updates);
+        }
+    }
+    // private async handleReorderSpaces(
+    //   documentId: string,
+    //   action: ReorderSpacesAction,
+    //   state: BuilderAccountState
+    // ): Promise<void> {
+    //   const { ids, insertAfter } = action.input;
+    //   for (let i = 0; i < ids.length; i++) {
+    //     const spaceId = ids[i];
+    //     const sortOrder = insertAfter !== null ? Number(insertAfter) + i + 1 : i;
+    //     await this.dbHelpers.updateBuilderSpace(spaceId, documentId, {
+    //       sort_order: sortOrder,
+    //     });
+    //   }
+    // }
+    // Packages operations
+    async handleAddPackage(documentId, action, state) {
+        await this.db
+            .insertInto("builder_team_packages")
+            .values({
+            id: `${action.input.id}`,
+            space_id: action.input.spaceId,
+            title: "",
+            description: "",
+            category: "",
+            author_name: "",
+            author_website: "",
+            github_url: "",
+            npm_url: "",
+            vetra_drive_url: "",
+            drive_id: "",
+            sort_order: 0,
+            created_at: new Date(),
+            updated_at: new Date(),
+        })
+            .onConflict((oc) => oc.column("id").doNothing())
+            .execute();
+        // // Add keywords if provided
+        // if (action.input.keywords && action.input.keywords.length > 0) {
+        //   for (const keyword of action.input.keywords) {
+        //     await this.db
+        //       .insertInto("builder_package_keywords")
+        //       .values({
+        //         id: `${packageId}-${keyword}`,
+        //         package_id: packageId,
+        //         label: keyword,
+        //         created_at: new Date(),
+        //       })
+        //       .execute();
+        //   }
+        // }
+    }
+    async handleUpdatePackageInfo(documentId, action, state) {
+        const updates = {};
+        // Map input fields to database columns, only include provided fields
+        if (action.input.title !== undefined) {
+            updates.title = action.input.title;
+        }
+        if (action.input.description !== undefined) {
+            updates.description = action.input.description;
+        }
+        if (action.input.github !== undefined) {
+            updates.github_url = action.input.github;
+        }
+        if (action.input.npm !== undefined) {
+            updates.npm_url = action.input.npm;
+        }
+        if (action.input.vetraDriveUrl !== undefined) {
+            updates.vetra_drive_url = action.input.vetraDriveUrl;
+        }
+        if (action.input.spaceId !== undefined) {
+            updates.space_id = action.input.spaceId;
+        }
+        // Note: phid is not stored in the packages table, and id is the WHERE condition
+        // Only update if there are actual changes
+        if (Object.keys(updates).length > 0) {
+            await this.dbHelpers.updateBuilderPackage(action.input.id, updates);
+        }
+    }
+    // private async handleReorderPackages(
+    //   documentId: string,
+    //   action: ReorderPackagesAction,
+    //   state: BuilderAccountState
+    // ): Promise<void> {
+    //   const { ids, insertAfter, spaceId } = action.input;
+    //   for (let i = 0; i < ids.length; i++) {
+    //     const packageId = ids[i];
+    //     const sortOrder = insertAfter !== null ? Number(insertAfter) + i + 1 : i;
+    //     await this.db
+    //       .updateTable("builder_packages")
+    //       .set({
+    //         sort_order: sortOrder,
+    //         updated_at: new Date(),
+    //       })
+    //       .where("id", "=", packageId)
+    //       .where("space_id", "=", spaceId)
+    //       .execute();
+    //   }
+    // }
+    async handleDeletePackage(documentId, action, state) {
+        await this.db
+            .deleteFrom("builder_team_packages")
+            .where("id", "=", action.input.id)
+            .execute();
+    }
+}

package/dist/processors/vetra-builder-relational-db-processor/database-helpers.d.ts

@@ -0,0 +1,39 @@
+import type { IRelationalDb } from "document-drive";
+import type { DB } from "./schema.js";
+export declare class DatabaseHelpers {
+    private db;
+    constructor(db: IRelationalDb<DB>);
+    /**
+     * Ensures a package exists in the database, creating it if it doesn't
+     */
+    ensurePackageExists(documentId: string, driveId: string): Promise<void>;
+    /**
+     * Check if a document ID is marked as deleted
+     */
+    private isDocumentDeleted;
+    /**
+     * Ensures a builder account exists in the database, creating it if it doesn't
+     * Throws an error if the document was previously deleted
+     */
+    ensureBuilderAccountExistsAndIsNotdeleted(documentId: string): Promise<void>;
+    /**
+     * Updates a package with the provided data
+     */
+    updatePackage(documentId: string, updates: Record<string, any>): Promise<void>;
+    /**
+     * Updates a builder account with the provided data
+     */
+    updateBuilderAccount(documentId: string, updates: Record<string, any>): Promise<void>;
+    /**
+     * Updates a builder space with the provided data
+     */
+    updateBuilderSpace(spaceId: string, documentId: string, updates: Record<string, any>): Promise<void>;
+    /**
+     * Updates a builder package with the provided data
+     */
+    updateBuilderPackage(packageId: string, updates: Record<string, any>): Promise<void>;
+    /**
+     * Checks if a member already exists for a builder account
+     */
+    memberExists(documentId: string, ethAddress: string): Promise<boolean>;
+}

package/dist/processors/vetra-builder-relational-db-processor/database-helpers.js

@@ -0,0 +1,144 @@
+export class DatabaseHelpers {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * Ensures a package exists in the database, creating it if it doesn't
+     */
+    async ensurePackageExists(documentId, driveId) {
+        const existing = await this.db
+            .selectFrom("builder_team_packages")
+            .select("id")
+            .where("id", "=", documentId)
+            .executeTakeFirst();
+        if (!existing) {
+            await this.db
+                .insertInto("builder_team_packages")
+                .values({
+                id: documentId,
+                drive_id: driveId,
+                author_name: "",
+                title: "",
+                space_id: "",
+            })
+                .execute();
+        }
+    }
+    /**
+     * Check if a document ID is marked as deleted
+     */
+    async isDocumentDeleted(documentId) {
+        try {
+            const result = await this.db
+                .selectFrom("deleted_files")
+                .select("id")
+                .where("document_id", "=", documentId)
+                .executeTakeFirst();
+            return !!result;
+        }
+        catch (error) {
+            console.error("Error checking if document is deleted:", error);
+            return false;
+        }
+    }
+    /**
+     * Ensures a builder account exists in the database, creating it if it doesn't
+     * Throws an error if the document was previously deleted
+     */
+    async ensureBuilderAccountExistsAndIsNotdeleted(documentId) {
+        // Check if the document was deleted
+        const isDeleted = await this.isDocumentDeleted(documentId);
+        if (isDeleted) {
+            throw new Error(`Builder account with document ID ${documentId} was previously deleted and cannot be accessed`);
+        }
+        const existing = await this.db
+            .selectFrom("builder_teams")
+            .select("id")
+            .where("id", "=", documentId)
+            .executeTakeFirst();
+        if (!existing) {
+            await this.db
+                .insertInto("builder_teams")
+                .values({
+                id: documentId,
+                profile_name: "",
+                profile_slug: "",
+                profile_logo: null,
+                profile_description: null,
+                profile_socials_x: null,
+                profile_socials_github: null,
+                profile_socials_website: null,
+                created_at: new Date(),
+                updated_at: new Date(),
+            })
+                .onConflict((oc) => oc.column("id").doNothing())
+                .execute();
+        }
+    }
+    /**
+     * Updates a package with the provided data
+     */
+    async updatePackage(documentId, updates) {
+        await this.db
+            .updateTable("builder_team_packages")
+            .set({
+            ...updates,
+            updated_at: new Date(),
+        })
+            .where("id", "=", documentId)
+            .execute();
+    }
+    /**
+     * Updates a builder account with the provided data
+     */
+    async updateBuilderAccount(documentId, updates) {
+        await this.db
+            .updateTable("builder_teams")
+            .set({
+            ...updates,
+            updated_at: new Date(),
+        })
+            .where("id", "=", documentId)
+            .execute();
+    }
+    /**
+     * Updates a builder space with the provided data
+     */
+    async updateBuilderSpace(spaceId, documentId, updates) {
+        await this.db
+            .updateTable("builder_team_spaces")
+            .set({
+            ...updates,
+            updated_at: new Date(),
+        })
+            .where("id", "=", spaceId)
+            .where("builder_team_id", "=", documentId)
+            .execute();
+    }
+    /**
+     * Updates a builder package with the provided data
+     */
+    async updateBuilderPackage(packageId, updates) {
+        await this.db
+            .updateTable("builder_team_packages")
+            .set({
+            ...updates,
+            updated_at: new Date(),
+        })
+            .where("id", "=", packageId)
+            .execute();
+    }
+    /**
+     * Checks if a member already exists for a builder account
+     */
+    async memberExists(documentId, ethAddress) {
+        const existing = await this.db
+            .selectFrom("builder_team_members")
+            .select("id")
+            .where("builder_team_id", "=", documentId)
+            .where("eth_address", "=", ethAddress)
+            .executeTakeFirst();
+        return !!existing;
+    }
+}

package/dist/processors/vetra-builder-relational-db-processor/factory.d.ts

@@ -0,0 +1,3 @@
+import { type IProcessorHostModule, type ProcessorRecord } from "document-drive/processors/types";
+import { type PHDocumentHeader } from "document-model";
+export declare const vetraBuilderTeamRelationalDbProcessorFactory: (module: IProcessorHostModule) => (driveHeader: PHDocumentHeader) => Promise<ProcessorRecord[]>;

package/dist/processors/vetra-builder-relational-db-processor/factory.js

@@ -0,0 +1,23 @@
+import { VetraBuilderRelationalDbProcessor } from "./index.js";
+export const vetraBuilderTeamRelationalDbProcessorFactory = (module) => async (driveHeader) => {
+    // Create a namespace for the processor and the provided drive id
+    const namespace = VetraBuilderRelationalDbProcessor.getNamespace(driveHeader.id);
+    // 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/builder-team", "powerhouse/document-drive"],
+        scope: ["global"],
+    };
+    // Create the processor
+    const processor = new VetraBuilderRelationalDbProcessor(namespace, filter, store);
+    console.log("vetraBuilderRelationalDbProcessorFactory", processor);
+    return [
+        {
+            processor,
+            filter,
+        },
+    ];
+};

package/dist/processors/vetra-builder-relational-db-processor/index.d.ts

@@ -0,0 +1,13 @@
+import type { IRelationalDb } from "document-drive";
+import { RelationalDbProcessor, type RelationalDbProcessorFilter } from "document-drive/processors/relational";
+import { type InternalTransmitterUpdate } from "document-drive/server/listener/transmitter/internal";
+import { type DB } from "./schema.js";
+export declare class VetraBuilderRelationalDbProcessor extends RelationalDbProcessor<DB> {
+    static getNamespace(driveId: string): string;
+    private builderTeamHandlers;
+    constructor(_namespace: string, _filter: RelationalDbProcessorFilter, relationalDb: IRelationalDb<DB>);
+    initAndUpgrade(): Promise<void>;
+    onStrands(strands: InternalTransmitterUpdate[]): Promise<void>;
+    private handleDocumentDriveOperation;
+    onDisconnect(): Promise<void>;
+}

package/dist/processors/vetra-builder-relational-db-processor/index.js

@@ -0,0 +1,53 @@
+import { RelationalDbProcessor, } from "document-drive/processors/relational";
+import { BuilderTeamHandlers } from "./builder-team-handlers.js";
+import { up } from "./migrations.js";
+export class VetraBuilderRelationalDbProcessor extends RelationalDbProcessor {
+    static getNamespace(driveId) {
+        // Default namespace: `${this.name}_${driveId.replaceAll("-", "_")}`
+        return super.getNamespace(driveId);
+    }
+    builderTeamHandlers;
+    constructor(_namespace, _filter, relationalDb) {
+        super(_namespace, _filter, relationalDb);
+        this.builderTeamHandlers = new BuilderTeamHandlers(relationalDb);
+    }
+    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;
+            }
+            console.log("onStrands", strand);
+            for (const operation of strand.operations) {
+                if (strand.documentType.includes("powerhouse/document-drive")) {
+                    await this.handleDocumentDriveOperation(strand.documentId, strand.driveId, operation.action, operation.state);
+                }
+                else {
+                    await this.builderTeamHandlers.handleBuilderTeamOperation(strand.documentId, operation.action, operation.state);
+                }
+            }
+        }
+    }
+    async handleDocumentDriveOperation(documentId, driveId = "", action, state) {
+        switch (action.type) {
+            case "DELETE_NODE":
+                await this.relationalDb
+                    .insertInto("deleted_files")
+                    .values({
+                    id: documentId + "-" + action.input.id,
+                    document_id: action.input.id,
+                    drive_id: driveId,
+                    deleted_at: new Date(),
+                })
+                    .onConflict((oc) => oc.column("id").doNothing())
+                    .execute();
+                break;
+        }
+    }
+    async onDisconnect() { }
+}

package/dist/processors/vetra-builder-relational-db-processor/migrations.d.ts

@@ -0,0 +1,3 @@
+import { type IRelationalDb } from "document-drive/processors/types";
+export declare function up(db: IRelationalDb<any>): Promise<void>;
+export declare function down(db: IRelationalDb<any>): Promise<void>;