@powerhousedao/vetra-builder-package 0.0.15 → 0.0.17

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

@@ -0,0 +1,370 @@
+import { RelationalDbProcessor } from "document-drive/processors/relational";
+import { up } from "./migrations.js";
+import { toPascalCase } from "document-drive/utils/misc";
+export class VetraBuilderReadModelProcessor 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) {
+                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 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":
+                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.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, state) {
+        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, state) {
+        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, state) {
+        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, state) {
+        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, state) {
+        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: 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.relationalDb
+            .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.ensureBuilderAccount(documentId);
+        const spaceId = toPascalCase(action.input.title);
+        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, state) {
+        await this.relationalDb
+            .deleteFrom("builder_spaces")
+            .where("id", "=", action.input.id)
+            .where("builder_account_id", "=", documentId)
+            .execute();
+    }
+    async handleSetSpaceTitle(documentId, action, state) {
+        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, state) {
+        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, 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.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, state) {
+        const packageId = action.input.spaceId + "-" + toPascalCase(action.input.name);
+        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: `${packageId}-${keyword}`,
+                    package_id: packageId,
+                    label: keyword,
+                    created_at: new Date(),
+                })
+                    .execute();
+            }
+        }
+    }
+    async handleSetPackageDriveId(documentId, action, state) {
+        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, state) {
+        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, 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.relationalDb
+                .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.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-builder-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-builder-read-model/migrations.js

@@ -0,0 +1,152 @@
+export async function up(db) {
+    if (process.env.NODE_ENV !== "production") {
+        await down(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 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")
+        .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();
+    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();
+    await db.schema.dropTable("builder_account_members").ifExists().execute();
+    await db.schema.dropTable("builder_accounts").ifExists().execute();
+}

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

@@ -0,0 +1,20 @@
+import type { Action } from "document-model";
+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 PackageHandlers {
+    private db;
+    private dbHelpers;
+    constructor(db: IRelationalDb<DB>);
+    handlePackageOperation(documentId: string, action: Action, state: BuilderAccountState, driveId?: string): Promise<void>;
+    private handleSetPackageName;
+    private handleSetPackageDescription;
+    private handleSetPackageCategory;
+    private handleSetPackageAuthor;
+    private handleSetPackageAuthorName;
+    private handleSetPackageAuthorWebsite;
+    private handleAddPackageKeyword;
+    private handleRemovePackageKeyword;
+    private handleSetPackageGithubUrl;
+    private handleSetPackageNpmUrl;
+}

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

@@ -0,0 +1,116 @@
+import { DatabaseHelpers } from "./database-helpers.js";
+export class PackageHandlers {
+    db;
+    dbHelpers;
+    constructor(db) {
+        this.db = db;
+        this.dbHelpers = new DatabaseHelpers(db);
+    }
+    async handlePackageOperation(documentId, action, state, driveId) {
+        const packageDriveId = driveId || "";
+        switch (action.type) {
+            case "SET_PACKAGE_NAME":
+                await this.handleSetPackageName(documentId, packageDriveId, action, state);
+                break;
+            case "SET_PACKAGE_DESCRIPTION":
+                await this.handleSetPackageDescription(documentId, packageDriveId, action, state);
+                break;
+            case "SET_PACKAGE_CATEGORY":
+                await this.handleSetPackageCategory(documentId, packageDriveId, action, state);
+                break;
+            case "SET_PACKAGE_AUTHOR":
+                await this.handleSetPackageAuthor(documentId, packageDriveId, action, state);
+                break;
+            case "SET_PACKAGE_AUTHOR_NAME":
+                await this.handleSetPackageAuthorName(documentId, packageDriveId, action, state);
+                break;
+            case "SET_PACKAGE_AUTHOR_WEBSITE":
+                await this.handleSetPackageAuthorWebsite(documentId, packageDriveId, action, state);
+                break;
+            case "ADD_PACKAGE_KEYWORD":
+                await this.handleAddPackageKeyword(documentId, packageDriveId, action, state);
+                break;
+            case "REMOVE_PACKAGE_KEYWORD":
+                await this.handleRemovePackageKeyword(documentId, packageDriveId, action, state);
+                break;
+            case "SET_PACKAGE_GITHUB_URL":
+                await this.handleSetPackageGithubUrl(documentId, packageDriveId, action, state);
+                break;
+            case "SET_PACKAGE_NPM_URL":
+                await this.handleSetPackageNpmUrl(documentId, packageDriveId, action, state);
+                break;
+        }
+    }
+    async handleSetPackageName(documentId, driveId, action, state) {
+        await this.dbHelpers.ensurePackageExists(documentId, driveId);
+        await this.dbHelpers.updatePackage(documentId, {
+            name: action.input.name,
+        });
+    }
+    async handleSetPackageDescription(documentId, driveId, action, state) {
+        await this.dbHelpers.ensurePackageExists(documentId, driveId);
+        await this.dbHelpers.updatePackage(documentId, {
+            description: action.input.description,
+        });
+    }
+    async handleSetPackageCategory(documentId, driveId, action, state) {
+        await this.dbHelpers.ensurePackageExists(documentId, driveId);
+        await this.dbHelpers.updatePackage(documentId, {
+            category: action.input.category,
+        });
+    }
+    async handleSetPackageAuthor(documentId, driveId, action, state) {
+        await this.dbHelpers.ensurePackageExists(documentId, driveId);
+        const input = action.input;
+        await this.dbHelpers.updatePackage(documentId, {
+            author_name: input.name,
+            author_website: input.website,
+        });
+    }
+    async handleSetPackageAuthorName(documentId, driveId, action, state) {
+        await this.dbHelpers.ensurePackageExists(documentId, driveId);
+        await this.dbHelpers.updatePackage(documentId, {
+            author_name: action.input.name,
+        });
+    }
+    async handleSetPackageAuthorWebsite(documentId, driveId, action, state) {
+        await this.dbHelpers.ensurePackageExists(documentId, driveId);
+        await this.dbHelpers.updatePackage(documentId, {
+            author_website: action.input.website,
+        });
+    }
+    async handleAddPackageKeyword(documentId, driveId, action, state) {
+        await this.dbHelpers.ensurePackageExists(documentId, driveId);
+        const input = action.input;
+        await this.db
+            .insertInto("builder_package_keywords")
+            .values({
+            id: input.id,
+            package_id: documentId,
+            label: input.label,
+            created_at: new Date(),
+        })
+            .onConflict((oc) => oc.column("id").doNothing())
+            .execute();
+    }
+    async handleRemovePackageKeyword(documentId, driveId, action, state) {
+        const input = action.input;
+        await this.db
+            .deleteFrom("builder_package_keywords")
+            .where("id", "=", input.id)
+            .where("package_id", "=", documentId)
+            .execute();
+    }
+    async handleSetPackageGithubUrl(documentId, driveId, action, state) {
+        await this.dbHelpers.ensurePackageExists(documentId, driveId);
+        await this.dbHelpers.updatePackage(documentId, {
+            github_url: action.input.url,
+        });
+    }
+    async handleSetPackageNpmUrl(documentId, driveId, action, state) {
+        await this.dbHelpers.ensurePackageExists(documentId, driveId);
+        await this.dbHelpers.updatePackage(documentId, {
+            npm_url: action.input.url,
+        });
+    }
+}