@powerhousedao/vetra-builder-package 0.0.13 → 0.0.15

package/dist/powerhouse.manifest.json

@@ -14,15 +14,32 @@
         {
             "id": "powerhouse/vetra/package",
             "name": "VetraPackage"
+        },
+        {
+            "id": "powerhouse/renown-profile",
+            "name": "RenownProfile"
+        }
+    ],
+    "editors": [
+        {
+            "id": "renown-profile-editor",
+            "name": "RenownProfileEditor",
+            "documentTypes": [
+                "powerhouse/renown-profile"
+            ]
         }
     ],
-    "editors": [],
     "apps": [],
     "subgraphs": [
         {
             "id": "vetra",
             "name": "vetra",
             "documentTypes": []
+        },
+        {
+            "id": "renown-read-model",
+            "name": "RenownReadModel",
+            "documentTypes": []
         }
     ],
     "importScripts": []

package/dist/processors/factory.js

@@ -1,14 +1,11 @@
-/**
- * This file aggregates all processor factories
- * Auto-generated by codegen - DO NOT EDIT MANUALLY
- */
-// Import other processor factories here as they are generated
+import { renownProfileProcessorFactory } from "./renown-profile/factory.js";
 import { vetraReadModelProcessorFactory } from "./vetra-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));
     // Return the inner function that will be called for each drive
     return async (driveHeader) => {
         const processors = [];

package/dist/processors/index.d.ts

@@ -1,3 +1,5 @@
 export { VetraReadModelProcessor } from "./vetra-read-model/index.js";
 export { vetraReadModelProcessorFactory } from "./vetra-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,3 +1,5 @@
 export { VetraReadModelProcessor } from "./vetra-read-model/index.js";
 export { vetraReadModelProcessorFactory } from "./vetra-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/renown-profile/factory.d.ts

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

package/dist/processors/renown-profile/factory.js

@@ -0,0 +1,22 @@
+import { RenownProfileProcessor } from "./index.js";
+export const renownProfileProcessorFactory = (module) => async (driveHeader) => {
+    // Create a namespace for the processor and the provided drive id
+    const namespace = RenownProfileProcessor.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/renown-profile"],
+        scope: ["global"],
+    };
+    // Create the processor
+    const processor = new RenownProfileProcessor(namespace, filter, store);
+    return [
+        {
+            processor,
+            filter,
+        },
+    ];
+};

package/dist/processors/renown-profile/index.d.ts

@@ -0,0 +1,9 @@
+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 RenownProfileProcessor extends RelationalDbProcessor<DB> {
+    static getNamespace(driveId: string): string;
+    initAndUpgrade(): Promise<void>;
+    onStrands(strands: InternalTransmitterUpdate[]): Promise<void>;
+    onDisconnect(): Promise<void>;
+}

package/dist/processors/renown-profile/index.js

@@ -0,0 +1,81 @@
+import { RelationalDbProcessor } from "document-drive/processors/relational";
+import { up } from "./migrations.js";
+export class RenownProfileProcessor 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;
+            }
+            const documentId = strand.documentId;
+            // Ensure the profile exists in the database
+            const existingProfile = await this.relationalDb
+                .selectFrom("renown_profile")
+                .select(["document_id"])
+                .where("document_id", "=", documentId)
+                .executeTakeFirst();
+            if (!existingProfile) {
+                // Create a new profile entry
+                await this.relationalDb
+                    .insertInto("renown_profile")
+                    .values({
+                    document_id: documentId,
+                    username: null,
+                    eth_address: null,
+                    user_image: null,
+                    created_at: new Date(),
+                    updated_at: new Date(),
+                })
+                    .execute();
+            }
+            // Process each operation
+            for (const operation of strand.operations) {
+                // Update the profile based on the operation type
+                const updateData = {
+                    updated_at: new Date(),
+                };
+                switch (operation.action.type) {
+                    case "SET_USERNAME": {
+                        const input = operation.action.input;
+                        if (input?.username) {
+                            updateData.username = input.username;
+                        }
+                        break;
+                    }
+                    case "SET_ETH_ADDRESS": {
+                        const input = operation.action.input;
+                        if (input?.ethAddress) {
+                            updateData.eth_address = input.ethAddress;
+                        }
+                        break;
+                    }
+                    case "SET_USER_IMAGE": {
+                        const input = operation.action.input;
+                        if (input?.userImage !== undefined) {
+                            updateData.user_image = input.userImage || null;
+                        }
+                        break;
+                    }
+                }
+                // Apply updates if there are any field changes
+                if (Object.keys(updateData).length > 1) {
+                    await this.relationalDb
+                        .updateTable("renown_profile")
+                        .set(updateData)
+                        .where("document_id", "=", documentId)
+                        .execute();
+                }
+            }
+        }
+    }
+    async onDisconnect() { }
+}

package/dist/processors/renown-profile/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/renown-profile/migrations.js

@@ -0,0 +1,39 @@
+export async function up(db) {
+    await down(db);
+    // Create renown_profile table
+    await db.schema
+        .createTable("renown_profile")
+        .addColumn("document_id", "varchar(255)")
+        .addColumn("username", "varchar(255)")
+        .addColumn("eth_address", "varchar(42)")
+        .addColumn("user_image", "text")
+        .addColumn("created_at", "timestamp", (col) => col.defaultTo(db.fn("now")))
+        .addColumn("updated_at", "timestamp", (col) => col.defaultTo(db.fn("now")))
+        .addPrimaryKeyConstraint("renown_profile_pkey", ["document_id"])
+        .ifNotExists()
+        .execute();
+    // Create index on username for faster lookups
+    await db.schema
+        .createIndex("idx_renown_profile_username")
+        .on("renown_profile")
+        .column("username")
+        .ifNotExists()
+        .execute();
+    // Create index on eth_address for faster lookups
+    await db.schema
+        .createIndex("idx_renown_profile_eth_address")
+        .on("renown_profile")
+        .column("eth_address")
+        .ifNotExists()
+        .execute();
+}
+export async function down(db) {
+    // Drop indexes
+    await db.schema
+        .dropIndex("idx_renown_profile_eth_address")
+        .ifExists()
+        .execute();
+    await db.schema.dropIndex("idx_renown_profile_username").ifExists().execute();
+    // Drop tables
+    await db.schema.dropTable("renown_profile").ifExists().execute();
+}

package/dist/processors/renown-profile/schema.d.ts

@@ -0,0 +1,14 @@
+import type { ColumnType } from "kysely";
+export type Generated<T> = T extends ColumnType<infer S, infer I, infer U> ? ColumnType<S, I | undefined, U> : ColumnType<T, T | undefined, T>;
+export type Timestamp = ColumnType<Date, Date | string, Date | string>;
+export interface RenownProfile {
+    created_at: Generated<Timestamp | null>;
+    document_id: string;
+    eth_address: string | null;
+    updated_at: Generated<Timestamp | null>;
+    user_image: string | null;
+    username: string | null;
+}
+export interface DB {
+    renown_profile: RenownProfile;
+}

package/dist/processors/renown-profile/schema.js

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

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

@@ -0,0 +1,55 @@
+export async function up(db) {
+    if (process.env.NODE_ENV !== "production") {
+        await down(db);
+    }
+    // Create renown_profiles table
+    await db.schema
+        .createTable("renown_profiles")
+        .addColumn("id", "varchar(255)", (col) => col.primaryKey())
+        .addColumn("username", "varchar(255)")
+        .addColumn("eth_address", "varchar(42)") // Ethereum addresses are 42 chars
+        .addColumn("user_image", "text")
+        .addColumn("created_at", "timestamp", (col) => col.defaultTo("now()").notNull())
+        .addColumn("updated_at", "timestamp", (col) => col.defaultTo("now()").notNull())
+        .ifNotExists()
+        .execute();
+    // Create deleted_files table
+    await db.schema
+        .createTable("deleted_files")
+        .addColumn("id", "varchar(255)", (col) => col.primaryKey())
+        .addColumn("document_id", "varchar(255)", (col) => col.notNull())
+        .addColumn("drive_id", "varchar(255)", (col) => col.notNull())
+        .addColumn("deleted_at", "timestamp", (col) => col.defaultTo("now()").notNull())
+        .ifNotExists()
+        .execute();
+    // Create indexes for better performance
+    await db.schema
+        .createIndex("idx_renown_profiles_username")
+        .on("renown_profiles")
+        .column("username")
+        .ifNotExists()
+        .execute();
+    await db.schema
+        .createIndex("idx_renown_profiles_eth_address")
+        .on("renown_profiles")
+        .column("eth_address")
+        .ifNotExists()
+        .execute();
+    await db.schema
+        .createIndex("idx_deleted_files_document_id")
+        .on("deleted_files")
+        .column("document_id")
+        .ifNotExists()
+        .execute();
+    await db.schema
+        .createIndex("idx_deleted_files_drive_id")
+        .on("deleted_files")
+        .column("drive_id")
+        .ifNotExists()
+        .execute();
+}
+export async function down(db) {
+    // Drop tables in reverse order due to foreign key constraints
+    await db.schema.dropTable("deleted_files").ifExists().execute();
+    await db.schema.dropTable("renown_profiles").ifExists().execute();
+}

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

@@ -0,0 +1,21 @@
+import type { ColumnType } from "kysely";
+export type Generated<T> = T extends ColumnType<infer S, infer I, infer U> ? ColumnType<S, I | undefined, U> : ColumnType<T, T | undefined, T>;
+export type Timestamp = ColumnType<Date, Date | string, Date | string>;
+export interface RenownProfiles {
+    id: string;
+    username: string | null;
+    eth_address: string | null;
+    user_image: string | null;
+    created_at: Generated<Timestamp>;
+    updated_at: Generated<Timestamp>;
+}
+export interface DeletedFiles {
+    id: string;
+    document_id: string;
+    drive_id: string;
+    deleted_at: Generated<Timestamp>;
+}
+export interface DB {
+    renown_profiles: RenownProfiles;
+    deleted_files: DeletedFiles;
+}

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

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

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

@@ -68,31 +68,31 @@ export class BuilderAccountHandlers {
     }
     // Profile operations
     async handleSetLogo(documentId, action, state) {
-        await this.dbHelpers.ensureBuilderAccount(documentId);
+        await this.dbHelpers.ensureBuilderAccountExistsAndIsNotdeleted(documentId);
         await this.dbHelpers.updateBuilderAccount(documentId, {
             profile_logo: action.input.logoUrl,
         });
     }
     async handleSetProfileName(documentId, action, state) {
-        await this.dbHelpers.ensureBuilderAccount(documentId);
+        await this.dbHelpers.ensureBuilderAccountExistsAndIsNotdeleted(documentId);
         await this.dbHelpers.updateBuilderAccount(documentId, {
             profile_name: action.input.name,
         });
     }
     async handleSetSlug(documentId, action, state) {
-        await this.dbHelpers.ensureBuilderAccount(documentId);
+        await this.dbHelpers.ensureBuilderAccountExistsAndIsNotdeleted(documentId);
         await this.dbHelpers.updateBuilderAccount(documentId, {
             profile_slug: action.input.slug,
         });
     }
     async handleSetProfileDescription(documentId, action, state) {
-        await this.dbHelpers.ensureBuilderAccount(documentId);
+        await this.dbHelpers.ensureBuilderAccountExistsAndIsNotdeleted(documentId);
         await this.dbHelpers.updateBuilderAccount(documentId, {
             profile_description: action.input.description,
         });
     }
     async handleUpdateSocials(documentId, action, state) {
-        await this.dbHelpers.ensureBuilderAccount(documentId);
+        await this.dbHelpers.ensureBuilderAccountExistsAndIsNotdeleted(documentId);
         await this.dbHelpers.updateBuilderAccount(documentId, {
             profile_socials_x: action.input.x,
             profile_socials_github: action.input.github,
@@ -101,7 +101,7 @@ export class BuilderAccountHandlers {
     }
     // Members operations
     async handleAddMember(documentId, action, state) {
-        await this.dbHelpers.ensureBuilderAccount(documentId);
+        await this.dbHelpers.ensureBuilderAccountExistsAndIsNotdeleted(documentId);
         if (!action.input.ethAddress)
             return;
         const memberExists = await this.dbHelpers.memberExists(documentId, action.input.ethAddress);
@@ -128,7 +128,7 @@ export class BuilderAccountHandlers {
     }
     // Spaces operations
     async handleAddSpace(documentId, action, state) {
-        await this.dbHelpers.ensureBuilderAccount(documentId);
+        await this.dbHelpers.ensureBuilderAccountExistsAndIsNotdeleted(documentId);
         const spaceId = toPascalCase(action.input.title);
         await this.db
             .insertInto("builder_spaces")

package/dist/processors/vetra-read-model/database-helpers.d.ts

@@ -7,10 +7,15 @@ export declare class DatabaseHelpers {
      * 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
      */
-    ensureBuilderAccount(documentId: string): Promise<void>;
+    ensureBuilderAccountExistsAndIsNotdeleted(documentId: string): Promise<void>;
     /**
      * Updates a package with the provided data
      */

package/dist/processors/vetra-read-model/database-helpers.js

@@ -25,10 +25,33 @@ export class DatabaseHelpers {
                 .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 ensureBuilderAccount(documentId) {
+    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")

package/dist/processors/vetra-read-model/document-drive-handlers.d.ts

@@ -0,0 +1,21 @@
+import type { Action } from "document-model";
+import type { DB } from "./schema.js";
+import type { IRelationalDb } from "document-drive";
+export type DocumentDriveAction = Action & {
+    type: "DELETE_NODE" | "ADD_FILE" | "ADD_FOLDER" | "UPDATE_FILE" | "UPDATE_NODE" | "COPY_NODE" | "MOVE_NODE";
+    input: any;
+};
+export declare class DocumentDriveHandlers {
+    private db;
+    constructor(db: IRelationalDb<DB>);
+    /**
+     * Check if a document ID is marked as deleted
+     */
+    isDocumentDeleted(documentId: string): Promise<boolean>;
+    /**
+     * Get all deleted document IDs for a specific drive
+     */
+    getDeletedDocumentsInDrive(driveId: string): Promise<string[]>;
+    handleDocumentDriveOperation(documentId: string, action: DocumentDriveAction, driveId?: string): Promise<void>;
+    private handleDeleteNode;
+}

package/dist/processors/vetra-read-model/document-drive-handlers.js

@@ -0,0 +1,77 @@
+export class DocumentDriveHandlers {
+    db;
+    constructor(db) {
+        this.db = db;
+        console.log("DocumentDriveHandlers constructor");
+    }
+    /**
+     * 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;
+        }
+    }
+    /**
+     * Get all deleted document IDs for a specific drive
+     */
+    async getDeletedDocumentsInDrive(driveId) {
+        try {
+            const results = await this.db
+                .selectFrom("deleted_files")
+                .select("document_id")
+                .where("drive_id", "=", driveId)
+                .execute();
+            return results.map((r) => r.document_id);
+        }
+        catch (error) {
+            console.error("Error getting deleted documents in drive:", error);
+            return [];
+        }
+    }
+    async handleDocumentDriveOperation(documentId, action, driveId) {
+        console.log("Handling document drive operation:", action.type);
+        switch (action.type) {
+            case "DELETE_NODE":
+                console.log("Deleting node:", action.input.nodeId);
+                await this.handleDeleteNode(documentId, action, driveId);
+                break;
+            // Add other document-drive operations as needed
+            // case "ADD_FILE":
+            //   await this.handleAddFile(documentId, action, driveId);
+            //   break;
+            // case "UPDATE_FILE":
+            //   await this.handleUpdateFile(documentId, action, driveId);
+            //   break;
+        }
+    }
+    async handleDeleteNode(documentId, action, driveId) {
+        try {
+            const { nodeId } = action.input;
+            // Store the deleted file/document ID in the deleted_files table
+            // documentId is the drive ID, nodeId is the specific file/node being deleted
+            await this.db
+                .insertInto("deleted_files")
+                .values({
+                id: `${documentId}-${nodeId}`, // Unique ID combining drive and node
+                document_id: nodeId, // The specific document/file that was deleted
+                drive_id: documentId, // The drive containing the deleted file
+                deleted_at: new Date(),
+            })
+                .onConflict((oc) => oc.column("id").doNothing())
+                .execute();
+        }
+        catch (error) {
+            console.error("Error handling delete node:", error);
+        }
+    }
+}

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

@@ -8,7 +8,10 @@ export const vetraReadModelProcessorFactory = (module) => async (driveHeader) =>
     const filter = {
         branch: ["main"],
         documentId: ["*"],
-        documentType: ["powerhouse/vetra/builder-account"],
+        documentType: [
+            "powerhouse/vetra/builder-account",
+            "powerhouse/document-drive",
+        ],
         scope: ["global"],
     };
     // Create the processor

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

@@ -5,7 +5,8 @@ export declare class VetraReadModelProcessor extends RelationalDbProcessor<DB> {
     static getNamespace(driveId: string): string;
     initAndUpgrade(): Promise<void>;
     onStrands(strands: InternalTransmitterUpdate[]): Promise<void>;
-    private handleOperation;
+    private handleDocumentDriveOperation;
+    private handlePackageOperation;
     private handleSetLogo;
     private handleSetProfileName;
     private handleSetSlug;

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

@@ -18,11 +18,32 @@ export class VetraReadModelProcessor extends RelationalDbProcessor {
                 continue;
             }
             for (const operation of strand.operations) {
-                await this.handleOperation(strand.documentId, operation.action, operation.state);
+                if (strand.documentType.includes("powerhouse/document-drive")) {
+                    await this.handleDocumentDriveOperation(strand.documentId, strand.driveId, operation.action, operation.state);
+                }
+                else {
+                    await this.handlePackageOperation(strand.documentId, operation.action, operation.state);
+                }
             }
         }
     }
-    async handleOperation(documentId, action, 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 handlePackageOperation(documentId, action, state) {
         switch (action.type) {
             // Profile operations
             case "SET_LOGO":

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

@@ -70,6 +70,15 @@ export async function up(db) {
         .addForeignKeyConstraint("builder_package_keywords_package_fk", ["package_id"], "builder_packages", ["id"], (cb) => cb.onDelete("cascade"))
         .ifNotExists()
         .execute();
+    // Create deleted_files table
+    await db.schema
+        .createTable("deleted_files")
+        .addColumn("id", "varchar(255)", (col) => col.primaryKey())
+        .addColumn("document_id", "varchar(255)", (col) => col.notNull())
+        .addColumn("drive_id", "varchar(255)", (col) => col.notNull())
+        .addColumn("deleted_at", "timestamp", (col) => col.defaultTo("now()").notNull())
+        .ifNotExists()
+        .execute();
     // Create indexes for better performance
     await db.schema
         .createIndex("idx_builder_accounts_slug")
@@ -119,9 +128,22 @@ export async function up(db) {
         .column("package_id")
         .ifNotExists()
         .execute();
+    await db.schema
+        .createIndex("idx_deleted_files_document_id")
+        .on("deleted_files")
+        .column("document_id")
+        .ifNotExists()
+        .execute();
+    await db.schema
+        .createIndex("idx_deleted_files_drive_id")
+        .on("deleted_files")
+        .column("drive_id")
+        .ifNotExists()
+        .execute();
 }
 export async function down(db) {
     // Drop tables in reverse order due to foreign key constraints
+    await db.schema.dropTable("deleted_files").ifExists().execute();
     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();