@powerhousedao/codegen 4.1.0-dev.10 → 4.1.0-dev.101

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model-subgraph/index.js

@@ -1,22 +1,34 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const change_case_1 = require("change-case");
-const generateDocumentModelMutations = {
-    params: ({ args, }) => {
-        const documentModel = JSON.parse(args.documentModel);
-        const latestSpec = documentModel.specifications[documentModel.specifications.length - 1];
-        return {
-            rootDir: args.rootDir,
-            subgraph: args.subgraph,
-            documentTypeId: documentModel.id,
-            documentType: documentModel.name,
-            schema: latestSpec.state.global.schema,
-            modules: latestSpec.modules.map((m) => ({
-                ...m,
-                name: (0, change_case_1.paramCase)(m.name),
-            })),
-        };
-    },
+// @ts-check
+const { paramCase, pascalCase, camelCase } = require("change-case");
+
+module.exports = {
+  params: ({ args }) => {
+    const documentModel = JSON.parse(args.documentModel);
+    const latestSpec =
+      documentModel.specifications[documentModel.specifications.length - 1];
+    const documentType = documentModel.name;
+    const pascalCaseDocumentType = pascalCase(documentType);
+    const camelCaseDocumentType = camelCase(documentType);
+    const phDocumentTypeName = `${pascalCaseDocumentType}Document`;
+    const documentTypeVariableName = `${camelCaseDocumentType}DocumentType`;
+    const packageName = args.packageName;
+    const paramCaseDocumentType = paramCase(documentType);
+    const documentModelDir = `${packageName}/document-models/${paramCaseDocumentType}`;
+    return {
+      phDocumentTypeName,
+      documentTypeVariableName,
+      pascalCaseDocumentType,
+      camelCaseDocumentType,
+      documentModelDir,
+      rootDir: args.rootDir,
+      subgraph: args.subgraph,
+      documentTypeId: documentModel.id,
+      documentType: documentModel.name,
+      schema: latestSpec.state.global.schema,
+      modules: latestSpec.modules.map((m) => ({
+        ...m,
+        name: paramCase(m.name),
+      })),
+    };
+  },
 };
-exports.default = generateDocumentModelMutations;
-//# sourceMappingURL=index.js.map

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model-subgraph/resolvers.esm.t

@@ -2,102 +2,126 @@
 to: "<%= rootDir %>/<%= h.changeCase.param(subgraph) %>/resolvers.ts"
 force: true
 ---
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-import { type Subgraph } from "@powerhousedao/reactor-api";
+import type { BaseSubgraph } from "@powerhousedao/reactor-api";
 import { addFile } from "document-drive";
-import { actions } from "../../document-models/<%- h.changeCase.param(documentType) %>/index.js";
-import { generateId } from "document-model";
+import { setName } from "document-model";
+import {
+  actions,
+  <%= documentTypeVariableName %>,
+} from "<%= documentModelDir %>";
+<% const inputTypes = modules.flatMap(m =>
+     m.operations.map(o => `${h.changeCase.pascalCase(o.name)}Input`)
+   );
+%>
+import type {
+  <%= phDocumentTypeName %>,
+  <%= inputTypes.join(',\n  ') %>
+} from "<%= documentModelDir %>";
 
-const DEFAULT_DRIVE_ID = "powerhouse";
-
-export const getResolvers = (subgraph: Subgraph): Record<string, any> => {
+export const getResolvers = (subgraph: BaseSubgraph): Record<string, unknown> => {
   const reactor = subgraph.reactor;
 
   return ({
     Query: {
-      <%- h.changeCase.pascal(documentType) %>: async (_: any, args: any, ctx: any) => {
+      <%- pascalCaseDocumentType %>: async () => {
         return {
-          getDocument: async (args: any) => {
-            const driveId: string = args.driveId || DEFAULT_DRIVE_ID;
-            const docId: string = args.docId || "";
-            const doc = await reactor.getDocument(driveId, docId);
-             return {
+          getDocument: async (args: { docId: string, driveId: string }) => {
+            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<<%= phDocumentTypeName %>>(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,
+              revision: doc.header?.revision?.global ?? 0,
             };
           },
-          getDocuments: async (args: any) => {
-            const driveId: string = args.driveId || DEFAULT_DRIVE_ID;
+          getDocuments: async (args: { driveId: string }) => {
+            const { driveId } = args;
             const docsIds = await reactor.getDocuments(driveId);
             const docs = await Promise.all(
               docsIds.map(async (docId) => {
-                const doc = await reactor.getDocument(driveId, docId);
+                const doc = await reactor.getDocument<<%= phDocumentTypeName %>>(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,
+                  revision: doc.header?.revision?.global ?? 0,
                 };
               }),
             );
 
             return docs.filter(
-              (doc) => doc.header.documentType === "<%- documentTypeId %>",
+              (doc) => doc.header.documentType === <%= documentTypeVariableName %>,
             );
           },
         };
       },
     },
     Mutation: {
-
-      <%- h.changeCase.pascal(documentType) %>_createDocument: async (_: any, args: any) => {
-        const driveId: string = args.driveId || DEFAULT_DRIVE_ID;
-        const docId = generateId();
+      <%- pascalCaseDocumentType %>_createDocument: async (_: unknown, args: { name: string, driveId?: string }) => {
+        const { driveId, name } = args;
+        const document = await reactor.addDocument(<%= documentTypeVariableName %>);
         
-        await reactor.addDriveAction(driveId, addFile({
-          id: docId,
-          name: args.name,
-          documentType: "<%- documentTypeId %>",
-          synchronizationUnits:[
-            { 
-              branch: "main", 
-              scope: "global", 
-              syncId: generateId(), 
-            },
-            { 
-              branch: "main", 
-              scope: "local", 
-              syncId: generateId(), 
-            }
-          ],
-        }));
+        if(driveId) {
+          await reactor.addAction(
+            driveId,
+            addFile({
+              name,
+              id: document.header.id,
+              documentType: <%= documentTypeVariableName %>,
+            }),
+          );
+        }
+
+        if(name) {
+          await reactor.addAction(
+            document.header.id,
+            setName(name),
+          );
+        }
 
-        return docId;
+        return document.header.id;
       },
 
 <% modules.forEach(module => { _%>
 <% module.operations.forEach(op => { _%>
-        <%- h.changeCase.pascal(documentType) + '_' + h.changeCase.camel(op.name) 
-        %>: async (_: any, args: any) => {
-            const driveId: string = args.driveId || DEFAULT_DRIVE_ID;
-            const docId: string = args.docId || "";
-            const doc = await reactor.getDocument(driveId, docId);
+        <%- pascalCaseDocumentType + '_' + h.changeCase.camel(op.name) %>: async (_: unknown, args: { docId: string, input: <%- h.changeCase.pascal(op.name) %>Input}) => {
+            const { docId, input } = args;
+            const doc = await reactor.getDocument<<%- pascalCaseDocumentType %>Document>(docId);
+            if(!doc) {
+              throw new Error("Document not found");
+            }
 
-            await reactor.addAction(
-                driveId,
+            const result = await reactor.addAction(
                 docId,
-                actions.<%- h.changeCase.camel(op.name) %>({...args.input})
+                actions.<%- h.changeCase.camel(op.name) %>(input)
             );
             
-            return (doc.header.revision["global"] ?? 0) + 1;
+            if(result.status !== "SUCCESS") {
+              throw new Error(result.error?.message ?? "Failed to <%- h.changeCase.camel(op.name) %>");
+            }
+
+            return true;
         },
 
 <%_ })}); %>

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model-subgraph/schema.esm.t

@@ -7,18 +7,12 @@ import type { DocumentNode } from "graphql";
 
 export const schema: DocumentNode = gql`
 """
-Subgraph definition for <%= h.changeCase.pascal(documentType) %> (<%- documentTypeId %>)
-
-"""
-<%- schema %> 
-
-"""
-Queries: <%= h.changeCase.pascal(documentType) %>
+Queries: <%= h.changeCase.pascal(documentType) %> Document
 """
 
 type <%- h.changeCase.pascal(documentType) %>Queries {
-    getDocument(driveId: String, docId: PHID): <%- h.changeCase.pascal(documentType) %>
-    getDocuments(driveId: String): [<%- h.changeCase.pascal(documentType) %>!]
+    getDocument(docId: PHID!, driveId: PHID): <%- h.changeCase.pascal(documentType) %>
+    getDocuments(driveId: String!): [<%- h.changeCase.pascal(documentType) %>!]
 }
 
 type Query {
@@ -30,7 +24,7 @@ Mutations: <%= h.changeCase.pascal(documentType) %>
 """
 type Mutation {
 
-    <%- h.changeCase.pascal(documentType) %>_createDocument(driveId:String, name:String): String
+    <%- h.changeCase.pascal(documentType) %>_createDocument(name:String!, driveId:String): String
 
 <% modules.forEach(module => { _%>
 <% module.operations.forEach(op => { _%>

package/dist/src/codegen/.hygen/templates/powerhouse/generate-drive-editor/components/CreateDocument.esm.t

@@ -2,49 +2,57 @@
 to: "<%= rootDir %>/<%= h.changeCase.param(name) %>/components/CreateDocument.tsx"
 unless_exists: true
 ---
-import { Button } from "@powerhousedao/design-system";
-import { type DocumentModelModule } from "document-model";
+import type { VetraDocumentModelModule } from "@powerhousedao/reactor-browser";
+import {
+  showCreateDocumentModal,
+  useAllowedDocumentModelModules,
+} from "@powerhousedao/reactor-browser";
 
-interface CreateDocumentProps {
-  documentModels?: DocumentModelModule[];
-  createDocument: (doc: DocumentModelModule) => void;
-}
-
-function getDocumentSpec(doc: DocumentModelModule) {
-  if ("documentModelState" in doc) {
-    return doc.documentModelState as DocumentModelModule["documentModel"];
-  }
+/**
+ * Document creation UI component.
+ * Displays available document types as clickable buttons.
+ */
+export function CreateDocument() {
+  const allowedDocumentModelModules = useAllowedDocumentModelModules();
 
-  return doc.documentModel;
-}
-
-export const CreateDocument: React.FC<CreateDocumentProps> = ({
-  documentModels,
-  createDocument,
-}) => {
   return (
-    <div className="px-6">
+    <div>
+      {/* Customize section title here */}
       <h3 className="mb-3 mt-4 text-sm font-bold text-gray-600">
-        New document
+        Create document
       </h3>
+      {/* Customize layout by changing flex-wrap, gap, or grid layout */}
       <div className="flex w-full flex-wrap gap-4">
-        {documentModels?.map((doc) => {
-          const spec = getDocumentSpec(doc);
+        {allowedDocumentModelModules?.map((documentModelModule) => {
           return (
-            <Button
-              key={spec.id}
-              color="light"
-              size="small"
-              className="cursor-pointer"
-              title={spec.name}
-              aria-description={spec.description}
-              onClick={() => createDocument(doc)}
-            >
-              <span className="text-sm">{spec.name}</span>
-            </Button>
+            <CreateDocumentButton
+              key={documentModelModule.documentModel.global.id}
+              documentModelModule={documentModelModule}
+            />
           );
         })}
       </div>
     </div>
   );
-}; 
+}
+
+type Props = {
+  documentModelModule: VetraDocumentModelModule;
+};
+function CreateDocumentButton({ documentModelModule }: Props) {
+  const documentType = documentModelModule.documentModel.global.id;
+  const documentModelName =
+    documentModelModule.documentModel.global.name || documentType;
+  const documentModelDescription =
+    documentModelModule.documentModel.global.description;
+  return (
+    <button
+      className="cursor-pointer rounded-md bg-gray-200 py-2 px-3 hover:bg-gray-300"
+      title={documentModelName}
+      aria-description={documentModelDescription}
+      onClick={() => showCreateDocumentModal(documentType)}
+    >
+      {documentModelName}
+    </button>
+  );
+}

package/dist/src/codegen/.hygen/templates/powerhouse/generate-drive-editor/components/DriveContents.esm.t

@@ -0,0 +1,23 @@
+---
+to: "<%= rootDir %>/<%= h.changeCase.param(name) %>/components/DriveContents.tsx"
+unless_exists: true
+---
+import { CreateDocument } from "./CreateDocument.js";
+import { EmptyState } from "./EmptyState.js";
+import { Files } from "./Files.js";
+import { Folders } from "./Folders.js";
+import { NavigationBreadcrumbs } from "./NavigationBreadcrumbs.js";
+
+/** Shows the documents and folders in the selected drive */
+export function DriveContents() {
+  return (
+    <div className="space-y-6 px-6">
+      <NavigationBreadcrumbs />
+      <Folders />
+      <Files />
+      <EmptyState />
+      <CreateDocument />
+    </div>
+  );
+}
+

package/dist/src/codegen/.hygen/templates/powerhouse/generate-drive-editor/components/DriveExplorer.esm.t

@@ -2,237 +2,31 @@
 to: "<%= rootDir %>/<%= h.changeCase.param(name) %>/components/DriveExplorer.tsx"
 unless_exists: true
 ---
-import {
-  type BaseUiFileNode,
-  type BaseUiFolderNode,
-  type BaseUiNode,
-  type UiFileNode,
-  type UiFolderNode,
-  type UiNode,
-} from "@powerhousedao/design-system";
-import { useCallback, useState, useRef, useEffect } from "react";
-import type { FileNode, GetDocumentOptions, Node } from "document-drive";
-import { FileItemsGrid } from "./FileItemsGrid.js";
-import { FolderItemsGrid } from "./FolderItemsGrid.js";
+import type { EditorProps } from "document-model";
 import { FolderTree } from "./FolderTree.js";
-import { useTransformedNodes } from "../hooks/useTransformedNodes.js";
-import { useSelectedFolderChildren } from "../hooks/useSelectedFolderChildren.js";
-import { EditorContainer } from "./EditorContainer.js";
-import type { DocumentModelModule } from "document-model";
-import { CreateDocumentModal } from "@powerhousedao/design-system";
-import { CreateDocument } from "./CreateDocument.js";
-import { type DriveEditorContext, useDriveContext } from "@powerhousedao/reactor-browser";
+import { DriveContents } from "./DriveContents.js";
 
-interface DriveExplorerProps {
-  driveId: string;
-  nodes: Node[];
-  onAddFolder: (name: string, parentFolder?: string) => void;
-  onDeleteNode: (nodeId: string) => void;
-  renameNode: (nodeId: string, name: string) => void;
-  onCopyNode: (nodeId: string, targetName: string, parentId?: string) => void;
-  context: DriveEditorContext;
-}
-
-export function DriveExplorer({
-  driveId,
-  nodes,
-  onDeleteNode,
-  renameNode,
-  onAddFolder,
-  onCopyNode,
-  context,
-}: DriveExplorerProps) {
-  const { getDocumentRevision } = context;
-
-  const [selectedNodeId, setSelectedNodeId] = useState<string | undefined>();
-  const [activeDocumentId, setActiveDocumentId] = useState<
-    string | undefined
-  >();
-  const [openModal, setOpenModal] = useState(false);
-  const selectedDocumentModel = useRef<DocumentModelModule | null>(null);
-  const { addDocument, documentModels } = useDriveContext();
-
-  // Dummy functions to satisfy component types
-  const dummyDuplicateNode = useCallback((node: BaseUiNode) => {
-    console.log("Duplicate node:", node);
-  }, []);
-
-  const dummyAddFile = useCallback(
-    async (file: File, parentNode: BaseUiNode | null) => {
-      console.log("Add file:", file, parentNode);
-    },
-    []
-  );
-
-  const dummyMoveNode = useCallback(
-    async (uiNode: BaseUiNode, targetNode: BaseUiNode) => {
-      console.log("Move node:", uiNode, targetNode);
-    },
-    []
-  );
-
-  const handleNodeSelect = useCallback((node: BaseUiFolderNode) => {
-    console.log("Selected node:", node);
-    setSelectedNodeId(node.id);
-  }, []);
-
-  const handleFileSelect = useCallback((node: BaseUiFileNode) => {
-    setActiveDocumentId(node.id);
-  }, []);
-
-  const handleEditorClose = useCallback(() => {
-    setActiveDocumentId(undefined);
-  }, []);
-
-  const onCreateDocument = useCallback(
-    async (fileName: string) => {
-      setOpenModal(false);
-
-      const documentModel = selectedDocumentModel.current;
-      if (!documentModel) return;
-
-      const node = await addDocument(
-        driveId,
-        fileName,
-        documentModel.documentModel.id,
-        selectedNodeId,
-      );
-
-      selectedDocumentModel.current = null;
-      setActiveDocumentId(node.id);
-    },
-    [addDocument, driveId, selectedNodeId]
-  );
-
-  const onSelectDocumentModel = useCallback(
-    (documentModel: DocumentModelModule) => {
-      selectedDocumentModel.current = documentModel;
-      setOpenModal(true);
-    },
-    []
-  );
-
-  const onGetDocumentRevision = useCallback(
-    (options?: GetDocumentOptions) => {
-      if (!activeDocumentId) return;
-      return getDocumentRevision?.(activeDocumentId, options);
-    },
-    [getDocumentRevision, activeDocumentId],
-  );
-
-  const filteredDocumentModels = documentModels;
-
-  // Transform nodes using the custom hook
-  const transformedNodes = useTransformedNodes(nodes, driveId);
-
-  // Separate folders and files
-  const folders = transformedNodes.filter(
-    (node): node is UiFolderNode => node.kind === "FOLDER"
-  );
-  const files = transformedNodes.filter(
-    (node): node is UiFileNode => node.kind === "FILE"
-  );
-
-  // Get children of selected folder using the custom hook
-  const selectedFolderChildren = useSelectedFolderChildren(
-    selectedNodeId,
-    folders,
-    files
-  );
-
-  // Get the active document info from nodes
-  const activeDocument = activeDocumentId
-    ? files.find((file) => file.id === activeDocumentId)
-    : undefined;
-
-  const documentModelModule = activeDocument
-    ? context.getDocumentModelModule(activeDocument.documentType)
-    : null;
-
-  const editorModule = activeDocument
-    ? context.getEditor(activeDocument.documentType)
-    : null;
+/**
+ * Main drive explorer component with sidebar navigation and content area.
+ * Layout: Left sidebar (folder tree) + Right content area (files/folders + document editor)
+ */
+export function DriveExplorer({ children }: EditorProps) {
+  // if a document is selected then it's editor will be passed as children
+  const showDocumentEditor = !!children;
 
   return (
     <div className="flex h-full">
-      {/* Sidebar */}
-      <div className="w-64 border-r border-gray-200 p-4 overflow-y-auto">
-        <h2 className="text-lg font-semibold mb-4">Folders</h2>
-        <FolderTree
-          folders={folders}
-          selectedNodeId={selectedNodeId}
-          onSelectNode={handleNodeSelect}
-        />
-      </div>
-
-      {/* Main Content */}
-      <div className="flex-1 p-4 overflow-y-auto">
-        {activeDocument && documentModelModule && editorModule ? (
-          <EditorContainer
-            context={{
-              ...context,
-              getDocumentRevision: onGetDocumentRevision,
-            }}
-            documentId={activeDocumentId!}
-            documentType={activeDocument.documentType}
-            driveId={driveId}
-            onClose={handleEditorClose}
-            title={activeDocument.name}
-            documentModelModule={documentModelModule}
-            editorModule={editorModule}
-          />
+      <FolderTree />
+      <div className="flex-1 overflow-y-auto p-4">
+        {/* Conditional rendering: Document editor or folder contents */}
+        {showDocumentEditor ? (
+          /* Document editor view */
+          children
         ) : (
-          <>
-            <h2 className="text-lg font-semibold mb-4">Contents</h2>
-
-            {/* Folders Section */}
-            <FolderItemsGrid
-              folders={selectedFolderChildren.folders}
-              onSelectNode={handleNodeSelect}
-              onRenameNode={renameNode}
-              onDuplicateNode={(uiNode) =>
-                onCopyNode(
-                  uiNode.id,
-                  "Copy of " + uiNode.name,
-                  uiNode.parentFolder
-                )
-              }
-              onDeleteNode={onDeleteNode}
-              onAddFile={dummyAddFile}
-              onCopyNode={async (uiNode, targetNode) =>
-                onCopyNode(uiNode.id, "Copy of " + uiNode.name, targetNode.id)
-              }
-              onMoveNode={dummyMoveNode}
-              isAllowedToCreateDocuments={true}
-              onAddFolder={onAddFolder}
-              parentFolderId={selectedNodeId}
-            />
-
-            {/* Files Section */}
-            <FileItemsGrid
-              files={selectedFolderChildren.files}
-              onSelectNode={handleFileSelect}
-              onRenameNode={renameNode}
-              onDuplicateNode={dummyDuplicateNode}
-              onDeleteNode={onDeleteNode}
-              isAllowedToCreateDocuments={true}
-            />
-
-            {/* Create Document Section */}
-            <CreateDocument
-              createDocument={onSelectDocumentModel}
-              documentModels={filteredDocumentModels}
-            />
-          </>
+          /* Folder contents view */
+          <DriveContents />
         )}
       </div>
-
-      {/* Create Document Modal */}
-      <CreateDocumentModal
-        onContinue={onCreateDocument}
-        onOpenChange={(open) => setOpenModal(open)}
-        open={openModal}
-      />
     </div>
   );
-} 
+}

package/dist/src/codegen/.hygen/templates/powerhouse/generate-drive-editor/components/EmptyState.esm.t

@@ -0,0 +1,19 @@
+---
+to: "<%= rootDir %>/<%= h.changeCase.param(name) %>/components/EmptyState.tsx"
+unless_exists: true
+---
+import { useNodesInSelectedDriveOrFolder } from "@powerhousedao/reactor-browser";
+
+/** Shows a message when the selected drive or folder is empty */
+export function EmptyState() {
+  const nodes = useNodesInSelectedDriveOrFolder();
+  const hasNodes = nodes.length > 0;
+  if (hasNodes) return null;
+
+  return (
+    <div className="py-12 text-center text-gray-500">
+      <p className="text-lg">This folder is empty</p>
+      <p className="mt-2 text-sm">Create your first document or folder below</p>
+    </div>
+  );
+}