@powerhousedao/vetra-builder-package 0.0.0

package/dist/subgraphs/vetra-package/resolvers.js

@@ -0,0 +1,168 @@
+import { addFile } from "document-drive";
+import { actions, } from "../../document-models/vetra-package/index.js";
+import { setName } from "document-model";
+export const getResolvers = (subgraph) => {
+    const reactor = subgraph.reactor;
+    return {
+        Query: {
+            VetraPackage: async () => {
+                return {
+                    getDocument: async (args) => {
+                        const { docId, driveId } = args;
+                        if (!docId) {
+                            throw new Error("Document id is required");
+                        }
+                        if (driveId) {
+                            const docIds = await reactor.getDocuments(driveId);
+                            if (!docIds.includes(docId)) {
+                                throw new Error(`Document with id ${docId} is not part of ${driveId}`);
+                            }
+                        }
+                        const doc = await reactor.getDocument(docId);
+                        return {
+                            driveId: driveId,
+                            ...doc,
+                            ...doc.header,
+                            created: doc.header.createdAtUtcIso,
+                            lastModified: doc.header.lastModifiedAtUtcIso,
+                            state: doc.state.global,
+                            stateJSON: doc.state.global,
+                            revision: doc.header?.revision?.global ?? 0,
+                        };
+                    },
+                    getDocuments: async (args) => {
+                        const { driveId } = args;
+                        const docsIds = await reactor.getDocuments(driveId);
+                        const docs = await Promise.all(docsIds.map(async (docId) => {
+                            const doc = await reactor.getDocument(docId);
+                            return {
+                                driveId: driveId,
+                                ...doc,
+                                ...doc.header,
+                                created: doc.header.createdAtUtcIso,
+                                lastModified: doc.header.lastModifiedAtUtcIso,
+                                state: doc.state.global,
+                                stateJSON: doc.state.global,
+                                revision: doc.header?.revision?.global ?? 0,
+                            };
+                        }));
+                        return docs.filter((doc) => doc.header.documentType === "powerhouse/vetra/package");
+                    },
+                };
+            },
+        },
+        Mutation: {
+            VetraPackage_createDocument: async (_, args) => {
+                const { driveId, name } = args;
+                const document = await reactor.addDocument("powerhouse/vetra/package");
+                if (driveId) {
+                    await reactor.addAction(driveId, addFile({
+                        name,
+                        id: document.header.id,
+                        documentType: "powerhouse/vetra/package",
+                    }));
+                }
+                if (name) {
+                    await reactor.addAction(document.header.id, setName(name));
+                }
+                return document.header.id;
+            },
+            VetraPackage_setPackageName: async (_, args) => {
+                const { docId, input } = args;
+                const doc = await reactor.getDocument(docId);
+                if (!doc) {
+                    throw new Error("Document not found");
+                }
+                const result = await reactor.addAction(docId, actions.setPackageName(input));
+                if (result.status !== "SUCCESS") {
+                    throw new Error(result.error?.message ?? "Failed to setPackageName");
+                }
+                return true;
+            },
+            VetraPackage_setPackageDescription: async (_, args) => {
+                const { docId, input } = args;
+                const doc = await reactor.getDocument(docId);
+                if (!doc) {
+                    throw new Error("Document not found");
+                }
+                const result = await reactor.addAction(docId, actions.setPackageDescription(input));
+                if (result.status !== "SUCCESS") {
+                    throw new Error(result.error?.message ?? "Failed to setPackageDescription");
+                }
+                return true;
+            },
+            VetraPackage_setPackageCategory: async (_, args) => {
+                const { docId, input } = args;
+                const doc = await reactor.getDocument(docId);
+                if (!doc) {
+                    throw new Error("Document not found");
+                }
+                const result = await reactor.addAction(docId, actions.setPackageCategory(input));
+                if (result.status !== "SUCCESS") {
+                    throw new Error(result.error?.message ?? "Failed to setPackageCategory");
+                }
+                return true;
+            },
+            VetraPackage_setPackageGithub: async (_, args) => {
+                const { docId, input } = args;
+                const doc = await reactor.getDocument(docId);
+                if (!doc) {
+                    throw new Error("Document not found");
+                }
+                const result = await reactor.addAction(docId, actions.setPackageGithub(input));
+                if (result.status !== "SUCCESS") {
+                    throw new Error(result.error?.message ?? "Failed to setPackageGithub");
+                }
+                return true;
+            },
+            VetraPackage_setPackageNpm: async (_, args) => {
+                const { docId, input } = args;
+                const doc = await reactor.getDocument(docId);
+                if (!doc) {
+                    throw new Error("Document not found");
+                }
+                const result = await reactor.addAction(docId, actions.setPackageNpm(input));
+                if (result.status !== "SUCCESS") {
+                    throw new Error(result.error?.message ?? "Failed to setPackageNpm");
+                }
+                return true;
+            },
+            VetraPackage_setAuthor: async (_, args) => {
+                const { docId, input } = args;
+                const doc = await reactor.getDocument(docId);
+                if (!doc) {
+                    throw new Error("Document not found");
+                }
+                const result = await reactor.addAction(docId, actions.setAuthor(input));
+                if (result.status !== "SUCCESS") {
+                    throw new Error(result.error?.message ?? "Failed to setAuthor");
+                }
+                return true;
+            },
+            VetraPackage_addKeywords: async (_, args) => {
+                const { docId, input } = args;
+                const doc = await reactor.getDocument(docId);
+                if (!doc) {
+                    throw new Error("Document not found");
+                }
+                const result = await reactor.addAction(docId, actions.addKeywords(input));
+                if (result.status !== "SUCCESS") {
+                    throw new Error(result.error?.message ?? "Failed to addKeywords");
+                }
+                return true;
+            },
+            VetraPackage_removeKeywords: async (_, args) => {
+                const { docId, input } = args;
+                const doc = await reactor.getDocument(docId);
+                if (!doc) {
+                    throw new Error("Document not found");
+                }
+                const result = await reactor.addAction(docId, actions.removeKeywords(input));
+                if (result.status !== "SUCCESS") {
+                    throw new Error(result.error?.message ?? "Failed to removeKeywords");
+                }
+                return true;
+            },
+        },
+    };
+};

package/dist/subgraphs/vetra-package/schema.d.ts

@@ -0,0 +1,2 @@
+import type { DocumentNode } from "graphql";
+export declare const schema: DocumentNode;

package/dist/subgraphs/vetra-package/schema.js

@@ -0,0 +1,123 @@
+import { gql } from "graphql-tag";
+export const schema = gql `
+  """
+  Subgraph definition for VetraPackage (powerhouse/vetra/package)
+  """
+  type VetraPackageState {
+    name: String!
+    description: String
+    category: String
+    author: VetraBuilderPackageAuthor!
+    keywords: [VetraBuilderPackageKeyword!]!
+    github: URL
+    npm: URL
+  }
+
+  type VetraBuilderPackageAuthor {
+    name: String!
+    website: URL
+  }
+
+  type VetraBuilderPackageKeyword {
+    id: OID!
+    label: String!
+  }
+
+  """
+  Queries: VetraPackage
+  """
+  type VetraPackageQueries {
+    getDocument(docId: PHID!, driveId: PHID): VetraPackage
+    getDocuments(driveId: String!): [VetraPackage!]
+  }
+
+  type Query {
+    VetraPackage: VetraPackageQueries
+  }
+
+  """
+  Mutations: VetraPackage
+  """
+  type Mutation {
+    VetraPackage_createDocument(name: String!, driveId: String): String
+
+    VetraPackage_setPackageName(
+      driveId: String
+      docId: PHID
+      input: VetraPackage_SetPackageNameInput
+    ): Int
+    VetraPackage_setPackageDescription(
+      driveId: String
+      docId: PHID
+      input: VetraPackage_SetPackageDescriptionInput
+    ): Int
+    VetraPackage_setPackageCategory(
+      driveId: String
+      docId: PHID
+      input: VetraPackage_SetPackageCategoryInput
+    ): Int
+    VetraPackage_setPackageGithub(
+      driveId: String
+      docId: PHID
+      input: VetraPackage_SetPackageGithubInput
+    ): Int
+    VetraPackage_setPackageNpm(
+      driveId: String
+      docId: PHID
+      input: VetraPackage_SetPackageNpmInput
+    ): Int
+    VetraPackage_setAuthor(
+      driveId: String
+      docId: PHID
+      input: VetraPackage_SetAuthorInput
+    ): Int
+    VetraPackage_addKeywords(
+      driveId: String
+      docId: PHID
+      input: VetraPackage_AddKeywordsInput
+    ): Int
+    VetraPackage_removeKeywords(
+      driveId: String
+      docId: PHID
+      input: VetraPackage_RemoveKeywordsInput
+    ): Int
+  }
+
+  """
+  Module: Meta
+  """
+  input VetraPackage_SetPackageNameInput {
+    "Add your inputs here"
+    name: String!
+  }
+  input VetraPackage_SetPackageDescriptionInput {
+    "Add your inputs here"
+    description: String!
+  }
+  input VetraPackage_SetPackageCategoryInput {
+    "Add your inputs here"
+    category: String!
+  }
+  input VetraPackage_SetPackageGithubInput {
+    "Add your inputs here"
+    github: URL!
+  }
+  input VetraPackage_SetPackageNpmInput {
+    "Add your inputs here"
+    npm: URL!
+  }
+  input VetraPackage_SetAuthorInput {
+    "Add your inputs here"
+    name: String!
+    website: URL
+  }
+  input VetraPackage_AddKeywordsInput {
+    "Add your inputs here"
+    id: OID
+    label: String!
+  }
+  input VetraPackage_RemoveKeywordsInput {
+    "Add your inputs here"
+    id: OID!
+  }
+`;

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

@@ -0,0 +1,10 @@
+import { Subgraph } from "@powerhousedao/reactor-api";
+import type { DocumentNode } from "graphql";
+export declare class VetraReadModelSubgraph extends Subgraph {
+    name: string;
+    typeDefs: DocumentNode;
+    resolvers: Record<string, unknown>;
+    additionalContextFields: {};
+    onSetup(): Promise<void>;
+    onDisconnect(): Promise<void>;
+}

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

@@ -0,0 +1,11 @@
+import { Subgraph } from "@powerhousedao/reactor-api";
+import { schema } from "./schema.js";
+import { getResolvers } from "./resolvers.js";
+export class VetraReadModelSubgraph extends Subgraph {
+    name = "vetra-read-model";
+    typeDefs = schema;
+    resolvers = getResolvers(this);
+    additionalContextFields = {};
+    async onSetup() { }
+    async onDisconnect() { }
+}

package/dist/subgraphs/vetra-read-model/resolvers.d.ts

@@ -0,0 +1,2 @@
+import { type Subgraph } from "@powerhousedao/reactor-api";
+export declare const getResolvers: (subgraph: Subgraph) => Record<string, unknown>;

package/dist/subgraphs/vetra-read-model/resolvers.js

@@ -0,0 +1,134 @@
+import { VetraReadModelProcessor } from "processors/index.js";
+export const getResolvers = (subgraph) => {
+    const reactor = subgraph.reactor;
+    const db = subgraph.relationalDb;
+    return {
+        Query: {
+            fetchAllBuilderAccounts: async (parent, args, context) => {
+                const driveId = context.driveId || "default";
+                const accounts = await VetraReadModelProcessor.query(driveId, db)
+                    .selectFrom("builder_accounts")
+                    .selectAll()
+                    .execute();
+                return accounts.map((account) => ({
+                    id: account.id,
+                    profileName: account.profile_name,
+                    profileSlug: account.profile_slug,
+                    profileLogo: account.profile_logo,
+                    profileDescription: account.profile_description,
+                    profileSocialsX: account.profile_socials_x,
+                    profileSocialsGithub: account.profile_socials_github,
+                    profileSocialsWebsite: account.profile_socials_website,
+                    createdAt: account.created_at.toISOString(),
+                    updatedAt: account.updated_at.toISOString(),
+                    spaces: [], // Will be resolved by field resolver
+                    members: [], // Will be resolved by field resolver
+                }));
+            },
+            fetchBuilderAccount: async (parent, args, context) => {
+                const driveId = context.driveId || "default";
+                const account = await VetraReadModelProcessor.query(driveId, db)
+                    .selectFrom("builder_accounts")
+                    .selectAll()
+                    .where("id", "=", args.id)
+                    .executeTakeFirst();
+                if (!account) {
+                    return null;
+                }
+                return {
+                    id: account.id,
+                    profileName: account.profile_name,
+                    profileSlug: account.profile_slug,
+                    profileLogo: account.profile_logo,
+                    profileDescription: account.profile_description,
+                    profileSocialsX: account.profile_socials_x,
+                    profileSocialsGithub: account.profile_socials_github,
+                    profileSocialsWebsite: account.profile_socials_website,
+                    createdAt: account.created_at.toISOString(),
+                    updatedAt: account.updated_at.toISOString(),
+                    spaces: [], // Will be resolved by field resolver
+                    members: [], // Will be resolved by field resolver
+                };
+            },
+        },
+        BuilderAccount: {
+            spaces: async (parent, args, context) => {
+                const driveId = context.driveId || "default";
+                const spaces = await VetraReadModelProcessor.query(driveId, db)
+                    .selectFrom("builder_spaces")
+                    .selectAll()
+                    .where("builder_account_id", "=", parent.id)
+                    .orderBy("sort_order", "asc")
+                    .execute();
+                return spaces.map((space) => ({
+                    id: space.id,
+                    builderAccountId: space.builder_account_id,
+                    title: space.title,
+                    description: space.description,
+                    sortOrder: space.sort_order,
+                    createdAt: space.created_at.toISOString(),
+                    updatedAt: space.updated_at.toISOString(),
+                    packages: [], // Will be resolved by field resolver
+                }));
+            },
+            members: async (parent, args, context) => {
+                const driveId = context.driveId || "default";
+                const members = await VetraReadModelProcessor.query(driveId, db)
+                    .selectFrom("builder_account_members")
+                    .selectAll()
+                    .where("builder_account_id", "=", parent.id)
+                    .execute();
+                return members.map((member) => ({
+                    id: member.id,
+                    builderAccountId: member.builder_account_id,
+                    ethAddress: member.eth_address,
+                    createdAt: member.created_at.toISOString(),
+                }));
+            },
+        },
+        BuilderSpace: {
+            packages: async (parent, args, context) => {
+                const driveId = context.driveId || "default";
+                const packages = await VetraReadModelProcessor.query(driveId, db)
+                    .selectFrom("builder_packages")
+                    .selectAll()
+                    .where("space_id", "=", parent.id)
+                    .orderBy("sort_order", "asc")
+                    .execute();
+                return packages.map((pkg) => ({
+                    id: pkg.id,
+                    spaceId: pkg.space_id,
+                    name: pkg.name,
+                    description: pkg.description,
+                    category: pkg.category,
+                    authorName: pkg.author_name,
+                    authorWebsite: pkg.author_website,
+                    githubUrl: pkg.github_url,
+                    npmUrl: pkg.npm_url,
+                    vetraDriveUrl: pkg.vetra_drive_url,
+                    driveId: pkg.drive_id,
+                    sortOrder: pkg.sort_order,
+                    createdAt: pkg.created_at.toISOString(),
+                    updatedAt: pkg.updated_at.toISOString(),
+                    keywords: [], // Will be resolved by field resolver
+                }));
+            },
+        },
+        BuilderPackage: {
+            keywords: async (parent, args, context) => {
+                const driveId = context.driveId || "default";
+                const keywords = await VetraReadModelProcessor.query(driveId, db)
+                    .selectFrom("builder_package_keywords")
+                    .selectAll()
+                    .where("package_id", "=", parent.id)
+                    .execute();
+                return keywords.map((keyword) => ({
+                    id: keyword.id,
+                    packageId: keyword.package_id,
+                    label: keyword.label,
+                    createdAt: keyword.created_at.toISOString(),
+                }));
+            },
+        },
+    };
+};

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

@@ -0,0 +1,2 @@
+import type { DocumentNode } from "graphql";
+export declare const schema: DocumentNode;

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

@@ -0,0 +1,69 @@
+import { gql } from "graphql-tag";
+export const schema = gql `
+  """
+  Subgraph definition for Vetra Read Model
+  """
+  type BuilderAccount {
+    id: String!
+    profileName: String!
+    profileSlug: String!
+    profileLogo: String
+    profileDescription: String
+    profileSocialsX: String
+    profileSocialsGithub: String
+    profileSocialsWebsite: String
+    createdAt: String!
+    updatedAt: String!
+    spaces: [BuilderSpace!]!
+    members: [BuilderAccountMember!]!
+  }
+
+  type BuilderSpace {
+    id: String!
+    builderAccountId: String!
+    title: String!
+    description: String
+    sortOrder: Int!
+    createdAt: String!
+    updatedAt: String!
+    packages: [BuilderPackage!]!
+  }
+
+  type BuilderPackage {
+    id: String!
+    spaceId: String!
+    name: String!
+    description: String
+    category: String
+    authorName: String!
+    authorWebsite: String
+    githubUrl: String
+    npmUrl: String
+    vetraDriveUrl: String
+    driveId: String
+    sortOrder: Int!
+    createdAt: String!
+    updatedAt: String!
+    keywords: [BuilderPackageKeyword!]!
+  }
+
+  type BuilderPackageKeyword {
+    id: String!
+    packageId: String!
+    label: String!
+    createdAt: String!
+  }
+
+  type BuilderAccountMember {
+    id: String!
+    builderAccountId: String!
+    ethAddress: String!
+    createdAt: String!
+  }
+
+  type Query {
+    example(driveId: String!): String
+    fetchAllBuilderAccounts: [BuilderAccount!]!
+    fetchBuilderAccount(id: String!): BuilderAccount
+  }
+`;

package/dist/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;

package/dist/vitest.config.js

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+import react from "@vitejs/plugin-react";
+export default defineConfig({
+    test: {
+        globals: true,
+    },
+    plugins: [react()],
+});

package/package.json

@@ -0,0 +1,131 @@
+{
+  "name": "@powerhousedao/vetra-builder-package",
+  "description": "",
+  "version": "0.0.0",
+  "license": "AGPL-3.0-only",
+  "type": "module",
+  "files": [
+    "/dist"
+  ],
+  "release": {
+    "branches": [
+      "main",
+      {
+        "name": "staging",
+        "prerelease": "staging"
+      },
+      {
+        "name": "dev",
+        "prerelease": "dev"
+      }
+    ],
+    "plugins": [
+      "@semantic-release/changelog",
+      "@semantic-release/git",
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      [
+        "@semantic-release/npm",
+        {
+          "npmPublish": true,
+          "tarballDir": "dist"
+        }
+      ],
+      "@semantic-release/github"
+    ]
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./document-models": {
+      "types": "./dist/document-models/index.d.ts",
+      "default": "./dist/document-models/index.js"
+    },
+    "./editors": {
+      "types": "./dist/editors/index.d.ts",
+      "default": "./dist/editors/index.js"
+    },
+    "./subgraphs": {
+      "types": "./dist/subgraphs/index.d.ts",
+      "default": "./dist/subgraphs/index.js"
+    },
+    "./processors": {
+      "types": "./dist/processors/index.d.ts",
+      "default": "./dist/processors/index.js"
+    },
+    "./manifest": {
+      "types": "./dist/manifest.d.ts",
+      "default": "./dist/manifest.js"
+    },
+    "./style.css": "./dist/style.css"
+  },
+  "dependencies": {
+    "@powerhousedao/builder-tools": "staging",
+    "@powerhousedao/common": "staging",
+    "@powerhousedao/design-system": "staging",
+    "@powerhousedao/document-engineering": "^1.36.0",
+    "document-model": "staging",
+    "graphql": "^16.10.0",
+    "graphql-tag": "^2.12.6",
+    "kysely": "^0.28.7",
+    "uuid": "^11.1.0",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@electric-sql/pglite": "^0.2.12",
+    "@eslint/js": "^9.22.0",
+    "@powerhousedao/analytics-engine-core": "^0.5.0",
+    "@powerhousedao/codegen": "staging",
+    "@powerhousedao/ph-cli": "staging",
+    "@powerhousedao/reactor-api": "staging",
+    "@powerhousedao/reactor-browser": "staging",
+    "@powerhousedao/reactor-local": "staging",
+    "@powerhousedao/scalars": "staging",
+    "@powerhousedao/switchboard": "staging",
+    "@powerhousedao/vetra": "staging",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@tailwindcss/cli": "^4.0.15",
+    "@testing-library/react": "^16.3.0",
+    "@types/node": "^22.13.11",
+    "@types/react": "^18.3.19",
+    "@vitejs/plugin-react": "^4.3.4",
+    "document-drive": "staging",
+    "eslint": "^9.22.0",
+    "eslint-plugin-react": "^7.37.4",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "globals": "^16.0.0",
+    "package-manager-detector": "^0.2.8",
+    "pm2": "^5.4.3",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "semantic-release": "^24.2.8",
+    "tailwindcss": "^4.1.4",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.30.1",
+    "vite": "^6.2.3",
+    "vitest": "^3.0.9"
+  },
+  "peerDependencies": {
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "build:tsc": "tsc",
+    "build:tsc:watch": "tsc --watch",
+    "build:css": "npx @tailwindcss/cli -i ./style.css -o ./dist/style.css",
+    "build:css:watch": "npx @tailwindcss/cli -i ./style.css -o ./dist/style.css --watch",
+    "build": "npm run build:tsc && npm run build:css",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "generate": "ph-cli generate",
+    "connect": "ph-cli connect",
+    "reactor": "ph-cli reactor",
+    "service": "ph-cli service",
+    "service-startup": "bash ./node_modules/@powerhousedao/ph-cli/dist/scripts/service-startup.sh",
+    "service-unstartup": "bash ./node_modules/@powerhousedao/ph-cli/dist/scripts/service-unstartup.sh"
+  }
+}