@powerhousedao/vetra-builder-package 0.0.15 → 0.0.17

package/dist/document-models/index.d.ts

@@ -1,3 +1,2 @@
 export {};
 export { module as BuilderAccount } from "./builder-account/index.js";
-export { module as RenownProfile } from "./renown-profile/index.js";

package/dist/document-models/index.js

@@ -1,2 +1 @@
 export { module as BuilderAccount } from "./builder-account/index.js";
-export { module as RenownProfile } from "./renown-profile/index.js";

package/dist/editors/index.d.ts

@@ -1,3 +1,2 @@
 export {};
 export { module as BuilderAccountEditor } from "./builder-account-editor/index.js";
-export { module as RenownProfileEditor } from "./renown-profile-editor/index.js";

package/dist/editors/index.js

@@ -1,2 +1 @@
 export { module as BuilderAccountEditor } from "./builder-account-editor/index.js";
-export { module as RenownProfileEditor } from "./renown-profile-editor/index.js";

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 import type { Manifest } from "document-model";
 export declare const manifest: Manifest;
-export declare const documentModels: (import("document-model").DocumentModelModule<import("./document-models/builder-account/gen").BuilderAccountPHState> | import("document-model").DocumentModelModule<import("./document-models/renown-profile/gen").RenownProfilePHState>)[];
+export declare const documentModels: import("document-model").DocumentModelModule<import("./document-models/builder-account/gen").BuilderAccountPHState>[];
 export declare const editors: import("document-model").EditorModule[];

package/dist/processors/factory.js

@@ -1,11 +1,13 @@
-import { renownProfileProcessorFactory } from "./renown-profile/factory.js";
-import { vetraReadModelProcessorFactory } from "./vetra-read-model/factory.js";
+/**
+ * This file aggregates all processor factories
+ * Auto-generated by codegen - DO NOT EDIT MANUALLY
+ */
+import { vetraBuilderReadModelProcessorFactory } from "./vetra-builder-read-model/factory.js";
 export const processorFactory = (module) => {
     // Initialize all processor factories once with the module
     const factories = [];
     // Add other processors here as they are generated
-    factories.push(vetraReadModelProcessorFactory(module));
-    factories.push(renownProfileProcessorFactory(module));
+    factories.push(vetraBuilderReadModelProcessorFactory(module));
     // Return the inner function that will be called for each drive
     return async (driveHeader) => {
         const processors = [];

package/dist/processors/index.d.ts

@@ -1,5 +1,3 @@
-export { VetraReadModelProcessor } from "./vetra-read-model/index.js";
-export { vetraReadModelProcessorFactory } from "./vetra-read-model/factory.js";
+export { VetraBuilderReadModelProcessor } from "./vetra-builder-read-model/index.js";
+export { vetraBuilderReadModelProcessorFactory } from "./vetra-builder-read-model/factory.js";
 export { processorFactory } from "./factory.js";
-export * as RenownProfileProcessor from "./renown-profile/index.js";
-export { renownProfileProcessorFactory } from "./renown-profile/factory.js";

package/dist/processors/index.js

@@ -1,5 +1,3 @@
-export { VetraReadModelProcessor } from "./vetra-read-model/index.js";
-export { vetraReadModelProcessorFactory } from "./vetra-read-model/factory.js";
+export { VetraBuilderReadModelProcessor } from "./vetra-builder-read-model/index.js";
+export { vetraBuilderReadModelProcessorFactory } from "./vetra-builder-read-model/factory.js";
 export { processorFactory } from "./factory.js";
-export * as RenownProfileProcessor from "./renown-profile/index.js";
-export { renownProfileProcessorFactory } from "./renown-profile/factory.js";

package/dist/processors/vetra-builder-read-model/builder-account-handlers.d.ts

@@ -0,0 +1,27 @@
+import type { BuilderAccountAction } from "../../document-models/builder-account/gen/actions.js";
+import type { BuilderAccountState } from "document-models/builder-account/index.js";
+import type { DB } from "./schema.js";
+import type { IRelationalDb } from "document-drive";
+export declare class BuilderAccountHandlers {
+    private db;
+    private dbHelpers;
+    constructor(db: IRelationalDb<DB>);
+    handleBuilderAccountOperation(documentId: string, action: BuilderAccountAction, state: BuilderAccountState, driveId?: string): Promise<void>;
+    private handleSetLogo;
+    private handleSetProfileName;
+    private handleSetSlug;
+    private handleSetProfileDescription;
+    private handleUpdateSocials;
+    private handleAddMember;
+    private handleRemoveMember;
+    private handleAddSpace;
+    private handleDeleteSpace;
+    private handleSetSpaceTitle;
+    private handleSetSpaceDescription;
+    private handleReorderSpaces;
+    private handleAddPackage;
+    private handleSetPackageDriveId;
+    private handleUpdatePackage;
+    private handleReorderPackages;
+    private handleDeletePackage;
+}

package/dist/processors/vetra-builder-read-model/builder-account-handlers.js

@@ -0,0 +1,249 @@
+import { toPascalCase } from "document-drive/utils/misc";
+import { DatabaseHelpers } from "./database-helpers.js";
+export class BuilderAccountHandlers {
+    db;
+    dbHelpers;
+    constructor(db) {
+        this.db = db;
+        this.dbHelpers = new DatabaseHelpers(db);
+    }
+    async handleBuilderAccountOperation(documentId, action, state, driveId) {
+        switch (action.type) {
+            // Profile operations
+            case "SET_LOGO":
+                await this.handleSetLogo(documentId, action, state);
+                break;
+            case "SET_PROFILE_NAME":
+                await this.handleSetProfileName(documentId, action, state);
+                break;
+            case "SET_SLUG":
+                await this.handleSetSlug(documentId, action, state);
+                break;
+            case "SET_PROFILE_DESCRIPTION":
+                await this.handleSetProfileDescription(documentId, action, state);
+                break;
+            case "UPDATE_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 "DELETE_SPACE":
+                await this.handleDeleteSpace(documentId, action, state);
+                break;
+            case "SET_SPACE_TITLE":
+                await this.handleSetSpaceTitle(documentId, action, state);
+                break;
+            case "SET_SPACE_DESCRIPTION":
+                await this.handleSetSpaceDescription(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 "SET_PACKAGE_DRIVE_ID":
+                await this.handleSetPackageDriveId(documentId, action, state);
+                break;
+            case "UPDATE_PACKAGE":
+                await this.handleUpdatePackage(documentId, action, state);
+                break;
+            case "REORDER_PACKAGES":
+                await this.handleReorderPackages(documentId, action, state);
+                break;
+            case "DELETE_PACKAGE":
+                await this.handleDeletePackage(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.logoUrl,
+        });
+    }
+    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.x,
+            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.ethAddress)
+            return;
+        const memberExists = await this.dbHelpers.memberExists(documentId, action.input.ethAddress);
+        if (!memberExists) {
+            await this.db
+                .insertInto("builder_account_members")
+                .values({
+                id: action.input.ethAddress,
+                builder_account_id: documentId,
+                eth_address: action.input.ethAddress,
+                created_at: new Date(),
+            })
+                .execute();
+        }
+    }
+    async handleRemoveMember(documentId, action, state) {
+        if (!action.input.ethAddress)
+            return;
+        await this.db
+            .deleteFrom("builder_account_members")
+            .where("builder_account_id", "=", documentId)
+            .where("eth_address", "=", action.input.ethAddress)
+            .execute();
+    }
+    // Spaces operations
+    async handleAddSpace(documentId, action, state) {
+        await this.dbHelpers.ensureBuilderAccountExistsAndIsNotdeleted(documentId);
+        const spaceId = toPascalCase(action.input.title);
+        await this.db
+            .insertInto("builder_spaces")
+            .values({
+            id: spaceId,
+            builder_account_id: documentId,
+            title: action.input.title,
+            description: action.input.description || null,
+            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_spaces")
+            .where("id", "=", action.input.id)
+            .where("builder_account_id", "=", documentId)
+            .execute();
+    }
+    async handleSetSpaceTitle(documentId, action, state) {
+        await this.dbHelpers.updateBuilderSpace(action.input.id, documentId, {
+            title: action.input.newTitle,
+        });
+    }
+    async handleSetSpaceDescription(documentId, action, state) {
+        await this.dbHelpers.updateBuilderSpace(action.input.id, documentId, {
+            description: action.input.description,
+        });
+    }
+    async handleReorderSpaces(documentId, action, state) {
+        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) {
+        const packageId = action.input.spaceId + "-" + toPascalCase(action.input.name);
+        await this.db
+            .insertInto("builder_packages")
+            .values({
+            id: `${packageId}`,
+            space_id: action.input.spaceId,
+            name: action.input.name,
+            description: action.input.description || null,
+            category: action.input.category || null,
+            author_name: action.input.author?.name || "",
+            author_website: action.input.author?.website || null,
+            github_url: action.input.github || null,
+            npm_url: action.input.npm || null,
+            vetra_drive_url: action.input.vetraDriveUrl || null,
+            drive_id: null,
+            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 handleSetPackageDriveId(documentId, action, state) {
+        await this.dbHelpers.updateBuilderPackage(action.input.packageId, {
+            drive_id: action.input.driveId,
+        });
+    }
+    async handleUpdatePackage(documentId, action, state) {
+        const updates = {};
+        if (action.input.title !== undefined) {
+            updates.name = action.input.title;
+        }
+        if (action.input.description !== undefined) {
+            updates.description = action.input.description;
+        }
+        await this.dbHelpers.updateBuilderPackage(action.input.id, updates);
+    }
+    async handleReorderPackages(documentId, action, state) {
+        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_packages")
+            .where("id", "=", action.input.id)
+            .execute();
+    }
+}

package/dist/processors/vetra-builder-read-model/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-read-model/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_packages")
+            .select("id")
+            .where("id", "=", documentId)
+            .executeTakeFirst();
+        if (!existing) {
+            await this.db
+                .insertInto("builder_packages")
+                .values({
+                id: documentId,
+                drive_id: driveId,
+                author_name: "",
+                name: "",
+                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_accounts")
+            .select("id")
+            .where("id", "=", documentId)
+            .executeTakeFirst();
+        if (!existing) {
+            await this.db
+                .insertInto("builder_accounts")
+                .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_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_accounts")
+            .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_spaces")
+            .set({
+            ...updates,
+            updated_at: new Date(),
+        })
+            .where("id", "=", spaceId)
+            .where("builder_account_id", "=", documentId)
+            .execute();
+    }
+    /**
+     * Updates a builder package with the provided data
+     */
+    async updateBuilderPackage(packageId, updates) {
+        await this.db
+            .updateTable("builder_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_account_members")
+            .select("id")
+            .where("builder_account_id", "=", documentId)
+            .where("eth_address", "=", ethAddress)
+            .executeTakeFirst();
+        return !!existing;
+    }
+}

package/dist/processors/vetra-builder-read-model/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 vetraBuilderReadModelProcessorFactory: (module: IProcessorHostModule) => (driveHeader: PHDocumentHeader) => Promise<ProcessorRecord[]>;

package/dist/processors/vetra-builder-read-model/factory.js

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

package/dist/processors/vetra-builder-read-model/index.d.ts

@@ -0,0 +1,29 @@
+import { RelationalDbProcessor } from "document-drive/processors/relational";
+import { type InternalTransmitterUpdate } from "document-drive/server/listener/transmitter/internal";
+import { type DB } from "./schema.js";
+export declare class VetraBuilderReadModelProcessor extends RelationalDbProcessor<DB> {
+    static getNamespace(driveId: string): string;
+    initAndUpgrade(): Promise<void>;
+    onStrands(strands: InternalTransmitterUpdate[]): Promise<void>;
+    private handleDocumentDriveOperation;
+    private handlePackageOperation;
+    private handleSetLogo;
+    private handleSetProfileName;
+    private handleSetSlug;
+    private handleSetProfileDescription;
+    private handleUpdateSocials;
+    private handleAddMember;
+    private handleRemoveMember;
+    private handleAddSpace;
+    private handleDeleteSpace;
+    private handleSetSpaceTitle;
+    private handleSetSpaceDescription;
+    private handleReorderSpaces;
+    private handleAddPackage;
+    private handleSetPackageDriveId;
+    private handleUpdatePackage;
+    private handleReorderPackages;
+    private handleDeletePackage;
+    private ensureBuilderAccount;
+    onDisconnect(): Promise<void>;
+}