@powerhousedao/vetra-builder-package 0.0.0

package/dist/processors/vetra-read-model/index.js

@@ -0,0 +1,349 @@
+import { RelationalDbProcessor } from "document-drive/processors/relational";
+import { up } from "./migrations.js";
+import { generateId } from "document-model";
+export class VetraReadModelProcessor 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.handleOperation(strand.documentId, operation.action);
+            }
+        }
+    }
+    async handleOperation(documentId, action) {
+        switch (action.type) {
+            // Profile operations
+            case "SET_LOGO":
+                await this.handleSetLogo(documentId, action);
+                break;
+            case "SET_PROFILE_NAME":
+                await this.handleSetProfileName(documentId, action);
+                break;
+            case "SET_SLUG":
+                await this.handleSetSlug(documentId, action);
+                break;
+            case "SET_PROFILE_DESCRIPTION":
+                await this.handleSetProfileDescription(documentId, action);
+                break;
+            case "UPDATE_SOCIALS":
+                await this.handleUpdateSocials(documentId, action);
+                break;
+            // Members operations
+            case "ADD_MEMBER":
+                await this.handleAddMember(documentId, action);
+                break;
+            case "REMOVE_MEMBER":
+                await this.handleRemoveMember(documentId, action);
+                break;
+            // Spaces operations
+            case "ADD_SPACE":
+                await this.handleAddSpace(documentId, action);
+                break;
+            case "DELETE_SPACE":
+                await this.handleDeleteSpace(documentId, action);
+                break;
+            case "SET_SPACE_TITLE":
+                await this.handleSetSpaceTitle(documentId, action);
+                break;
+            case "SET_SPACE_DESCRIPTION":
+                await this.handleSetSpaceDescription(documentId, action);
+                break;
+            case "REORDER_SPACES":
+                await this.handleReorderSpaces(documentId, action);
+                break;
+            // Packages operations
+            case "ADD_PACKAGE":
+                await this.handleAddPackage(documentId, action);
+                break;
+            case "SET_PACKAGE_DRIVE_ID":
+                await this.handleSetPackageDriveId(documentId, action);
+                break;
+            case "UPDATE_PACKAGE":
+                await this.handleUpdatePackage(documentId, action);
+                break;
+            case "REORDER_PACKAGES":
+                await this.handleReorderPackages(documentId, action);
+                break;
+            case "DELETE_PACKAGE":
+                await this.handleDeletePackage(documentId, action);
+                break;
+        }
+    }
+    // Profile operations
+    async handleSetLogo(documentId, action) {
+        await this.ensureBuilderAccount(documentId);
+        await this.relationalDb
+            .updateTable("builder_accounts")
+            .set({
+            profile_logo: action.input.logoUrl,
+            updated_at: new Date(),
+        })
+            .where("id", "=", documentId)
+            .execute();
+    }
+    async handleSetProfileName(documentId, action) {
+        await this.ensureBuilderAccount(documentId);
+        await this.relationalDb
+            .updateTable("builder_accounts")
+            .set({
+            profile_name: action.input.name,
+            updated_at: new Date(),
+        })
+            .where("id", "=", documentId)
+            .execute();
+    }
+    async handleSetSlug(documentId, action) {
+        await this.ensureBuilderAccount(documentId);
+        await this.relationalDb
+            .updateTable("builder_accounts")
+            .set({
+            profile_slug: action.input.slug,
+            updated_at: new Date(),
+        })
+            .where("id", "=", documentId)
+            .execute();
+    }
+    async handleSetProfileDescription(documentId, action) {
+        await this.ensureBuilderAccount(documentId);
+        await this.relationalDb
+            .updateTable("builder_accounts")
+            .set({
+            profile_description: action.input.description,
+            updated_at: new Date(),
+        })
+            .where("id", "=", documentId)
+            .execute();
+    }
+    async handleUpdateSocials(documentId, action) {
+        await this.ensureBuilderAccount(documentId);
+        await this.relationalDb
+            .updateTable("builder_accounts")
+            .set({
+            profile_socials_x: action.input.x,
+            profile_socials_github: action.input.github,
+            profile_socials_website: action.input.website,
+            updated_at: new Date(),
+        })
+            .where("id", "=", documentId)
+            .execute();
+    }
+    // Members operations
+    async handleAddMember(documentId, action) {
+        await this.ensureBuilderAccount(documentId);
+        if (!action.input.ethAddress)
+            return;
+        // Check if member already exists
+        const existingMember = await this.relationalDb
+            .selectFrom("builder_account_members")
+            .select("id")
+            .where("builder_account_id", "=", documentId)
+            .where("eth_address", "=", action.input.ethAddress)
+            .executeTakeFirst();
+        if (!existingMember) {
+            await this.relationalDb
+                .insertInto("builder_account_members")
+                .values({
+                id: generateId(),
+                builder_account_id: documentId,
+                eth_address: action.input.ethAddress,
+                created_at: new Date(),
+            })
+                .execute();
+        }
+    }
+    async handleRemoveMember(documentId, action) {
+        if (!action.input.ethAddress)
+            return;
+        await this.relationalDb
+            .deleteFrom("builder_account_members")
+            .where("builder_account_id", "=", documentId)
+            .where("eth_address", "=", action.input.ethAddress)
+            .execute();
+    }
+    // Spaces operations
+    async handleAddSpace(documentId, action) {
+        await this.ensureBuilderAccount(documentId);
+        const spaceId = generateId();
+        await this.relationalDb
+            .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) {
+        await this.relationalDb
+            .deleteFrom("builder_spaces")
+            .where("id", "=", action.input.id)
+            .where("builder_account_id", "=", documentId)
+            .execute();
+    }
+    async handleSetSpaceTitle(documentId, action) {
+        await this.relationalDb
+            .updateTable("builder_spaces")
+            .set({
+            title: action.input.newTitle,
+            updated_at: new Date(),
+        })
+            .where("id", "=", action.input.id)
+            .where("builder_account_id", "=", documentId)
+            .execute();
+    }
+    async handleSetSpaceDescription(documentId, action) {
+        await this.relationalDb
+            .updateTable("builder_spaces")
+            .set({
+            description: action.input.description,
+            updated_at: new Date(),
+        })
+            .where("id", "=", action.input.id)
+            .where("builder_account_id", "=", documentId)
+            .execute();
+    }
+    async handleReorderSpaces(documentId, action) {
+        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.relationalDb
+                .updateTable("builder_spaces")
+                .set({
+                sort_order: sortOrder,
+                updated_at: new Date(),
+            })
+                .where("id", "=", spaceId)
+                .where("builder_account_id", "=", documentId)
+                .execute();
+        }
+    }
+    // Packages operations
+    async handleAddPackage(documentId, action) {
+        const packageId = generateId();
+        await this.relationalDb
+            .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.relationalDb
+                    .insertInto("builder_package_keywords")
+                    .values({
+                    id: generateId(),
+                    package_id: packageId,
+                    label: keyword,
+                    created_at: new Date(),
+                })
+                    .execute();
+            }
+        }
+    }
+    async handleSetPackageDriveId(documentId, action) {
+        await this.relationalDb
+            .updateTable("builder_packages")
+            .set({
+            drive_id: action.input.driveId,
+            updated_at: new Date(),
+        })
+            .where("id", "=", action.input.packageId)
+            .execute();
+    }
+    async handleUpdatePackage(documentId, action) {
+        const updates = { updated_at: new Date() };
+        if (action.input.title !== undefined) {
+            updates.name = action.input.title;
+        }
+        if (action.input.description !== undefined) {
+            updates.description = action.input.description;
+        }
+        await this.relationalDb
+            .updateTable("builder_packages")
+            .set(updates)
+            .where("id", "=", action.input.id)
+            .execute();
+    }
+    async handleReorderPackages(documentId, action) {
+        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.relationalDb
+                .updateTable("builder_packages")
+                .set({
+                sort_order: sortOrder,
+                updated_at: new Date(),
+            })
+                .where("id", "=", packageId)
+                .where("space_id", "=", spaceId)
+                .execute();
+        }
+    }
+    async handleDeletePackage(documentId, action) {
+        await this.relationalDb
+            .deleteFrom("builder_packages")
+            .where("id", "=", action.input.id)
+            .execute();
+    }
+    // Helper method to ensure builder account exists
+    async ensureBuilderAccount(documentId) {
+        const existing = await this.relationalDb
+            .selectFrom("builder_accounts")
+            .select("id")
+            .where("id", "=", documentId)
+            .executeTakeFirst();
+        if (!existing) {
+            await this.relationalDb
+                .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();
+        }
+    }
+    async onDisconnect() { }
+}

package/dist/processors/vetra-read-model/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/vetra-read-model/migrations.js

@@ -0,0 +1,127 @@
+export async function up(db) {
+    // Create builder_accounts table
+    await db.schema
+        .createTable("builder_accounts")
+        .addColumn("id", "varchar(255)", (col) => col.primaryKey())
+        .addColumn("profile_name", "varchar(255)", (col) => col.notNull())
+        .addColumn("profile_slug", "varchar(255)", (col) => col.notNull())
+        .addColumn("profile_logo", "text")
+        .addColumn("profile_description", "text")
+        .addColumn("profile_socials_x", "text")
+        .addColumn("profile_socials_github", "text")
+        .addColumn("profile_socials_website", "text")
+        .addColumn("created_at", "timestamp", (col) => col.defaultTo("now()").notNull())
+        .addColumn("updated_at", "timestamp", (col) => col.defaultTo("now()").notNull())
+        .ifNotExists()
+        .execute();
+    // Create builder_account_members table
+    await db.schema
+        .createTable("builder_account_members")
+        .addColumn("id", "varchar(255)", (col) => col.primaryKey())
+        .addColumn("builder_account_id", "varchar(255)", (col) => col.notNull())
+        .addColumn("eth_address", "varchar(42)", (col) => col.notNull()) // Ethereum addresses are 42 chars
+        .addColumn("created_at", "timestamp", (col) => col.defaultTo("now()").notNull())
+        .addForeignKeyConstraint("builder_account_members_account_fk", ["builder_account_id"], "builder_accounts", ["id"], (cb) => cb.onDelete("cascade"))
+        .ifNotExists()
+        .execute();
+    // Create builder_spaces table
+    await db.schema
+        .createTable("builder_spaces")
+        .addColumn("id", "varchar(255)", (col) => col.primaryKey())
+        .addColumn("builder_account_id", "varchar(255)", (col) => col.notNull())
+        .addColumn("title", "varchar(255)", (col) => col.notNull())
+        .addColumn("description", "text")
+        .addColumn("sort_order", "integer", (col) => col.defaultTo(0).notNull())
+        .addColumn("created_at", "timestamp", (col) => col.defaultTo("now()").notNull())
+        .addColumn("updated_at", "timestamp", (col) => col.defaultTo("now()").notNull())
+        .addForeignKeyConstraint("builder_spaces_account_fk", ["builder_account_id"], "builder_accounts", ["id"], (cb) => cb.onDelete("cascade"))
+        .ifNotExists()
+        .execute();
+    // Create builder_packages table
+    await db.schema
+        .createTable("builder_packages")
+        .addColumn("id", "varchar(255)", (col) => col.primaryKey())
+        .addColumn("space_id", "varchar(255)", (col) => col.notNull())
+        .addColumn("name", "varchar(255)", (col) => col.notNull())
+        .addColumn("description", "text")
+        .addColumn("category", "varchar(255)")
+        .addColumn("author_name", "varchar(255)", (col) => col.notNull())
+        .addColumn("author_website", "text")
+        .addColumn("github_url", "text")
+        .addColumn("npm_url", "text")
+        .addColumn("vetra_drive_url", "text")
+        .addColumn("drive_id", "varchar(255)") // For SetPackageDriveId operation
+        .addColumn("sort_order", "integer", (col) => col.defaultTo(0).notNull())
+        .addColumn("created_at", "timestamp", (col) => col.defaultTo("now()").notNull())
+        .addColumn("updated_at", "timestamp", (col) => col.defaultTo("now()").notNull())
+        .addForeignKeyConstraint("builder_packages_space_fk", ["space_id"], "builder_spaces", ["id"], (cb) => cb.onDelete("cascade"))
+        .ifNotExists()
+        .execute();
+    // Create builder_package_keywords table
+    await db.schema
+        .createTable("builder_package_keywords")
+        .addColumn("id", "varchar(255)", (col) => col.primaryKey())
+        .addColumn("package_id", "varchar(255)", (col) => col.notNull())
+        .addColumn("label", "varchar(255)", (col) => col.notNull())
+        .addColumn("created_at", "timestamp", (col) => col.defaultTo("now()").notNull())
+        .addForeignKeyConstraint("builder_package_keywords_package_fk", ["package_id"], "builder_packages", ["id"], (cb) => cb.onDelete("cascade"))
+        .ifNotExists()
+        .execute();
+    // Create indexes for better performance
+    await db.schema
+        .createIndex("idx_builder_accounts_slug")
+        .on("builder_accounts")
+        .column("profile_slug")
+        .ifNotExists()
+        .execute();
+    await db.schema
+        .createIndex("idx_builder_account_members_account")
+        .on("builder_account_members")
+        .column("builder_account_id")
+        .ifNotExists()
+        .execute();
+    await db.schema
+        .createIndex("idx_builder_account_members_eth_address")
+        .on("builder_account_members")
+        .column("eth_address")
+        .ifNotExists()
+        .execute();
+    await db.schema
+        .createIndex("idx_builder_spaces_account")
+        .on("builder_spaces")
+        .column("builder_account_id")
+        .ifNotExists()
+        .execute();
+    await db.schema
+        .createIndex("idx_builder_spaces_sort_order")
+        .on("builder_spaces")
+        .column("sort_order")
+        .ifNotExists()
+        .execute();
+    await db.schema
+        .createIndex("idx_builder_packages_space")
+        .on("builder_packages")
+        .column("space_id")
+        .ifNotExists()
+        .execute();
+    await db.schema
+        .createIndex("idx_builder_packages_sort_order")
+        .on("builder_packages")
+        .column("sort_order")
+        .ifNotExists()
+        .execute();
+    await db.schema
+        .createIndex("idx_builder_package_keywords_package")
+        .on("builder_package_keywords")
+        .column("package_id")
+        .ifNotExists()
+        .execute();
+}
+export async function down(db) {
+    // Drop tables in reverse order due to foreign key constraints
+    await db.schema.dropTable("builder_package_keywords").ifExists().execute();
+    await db.schema.dropTable("builder_packages").ifExists().execute();
+    await db.schema.dropTable("builder_spaces").ifExists().execute();
+    await db.schema.dropTable("builder_account_members").ifExists().execute();
+    await db.schema.dropTable("builder_accounts").ifExists().execute();
+}

package/dist/processors/vetra-read-model/schema.d.ts

@@ -0,0 +1,56 @@
+export interface BuilderAccount {
+    id: string;
+    profile_name: string;
+    profile_slug: string;
+    profile_logo: string | null;
+    profile_description: string | null;
+    profile_socials_x: string | null;
+    profile_socials_github: string | null;
+    profile_socials_website: string | null;
+    created_at: Date;
+    updated_at: Date;
+}
+export interface BuilderAccountMember {
+    id: string;
+    builder_account_id: string;
+    eth_address: string;
+    created_at: Date;
+}
+export interface BuilderSpace {
+    id: string;
+    builder_account_id: string;
+    title: string;
+    description: string | null;
+    sort_order: number;
+    created_at: Date;
+    updated_at: Date;
+}
+export interface BuilderPackage {
+    id: string;
+    space_id: string;
+    name: string;
+    description: string | null;
+    category: string | null;
+    author_name: string;
+    author_website: string | null;
+    github_url: string | null;
+    npm_url: string | null;
+    vetra_drive_url: string | null;
+    drive_id: string | null;
+    sort_order: number;
+    created_at: Date;
+    updated_at: Date;
+}
+export interface BuilderPackageKeyword {
+    id: string;
+    package_id: string;
+    label: string;
+    created_at: Date;
+}
+export interface DB {
+    builder_accounts: BuilderAccount;
+    builder_account_members: BuilderAccountMember;
+    builder_spaces: BuilderSpace;
+    builder_packages: BuilderPackage;
+    builder_package_keywords: BuilderPackageKeyword;
+}

package/dist/processors/vetra-read-model/schema.js

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