@powerhousedao/codegen 4.1.0-dev.8 → 4.1.0-dev.80

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

@@ -1,28 +1,53 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const change_case_1 = require("change-case");
-exports.default = {
-    params: ({ args }) => {
-        const documentModel = JSON.parse(args.documentModel);
-        const latestSpec = documentModel.specifications[documentModel.specifications.length - 1];
-        const filteredModules = latestSpec.modules.filter((m) => m.name === args.module);
-        const actions = filteredModules.length > 0
-            ? filteredModules[0].operations.map((a) => ({
-                name: a.name,
-                hasInput: a.schema !== null,
-                hasAttachment: a.schema?.includes(": Attachment"),
-                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-                scope: a.scope || "global",
-                state: a.scope === "global" ? "" : a.scope, // the state this action affects
-                errors: a.errors,
-            }))
-            : [];
-        return {
-            rootDir: args.rootDir,
-            documentType: documentModel.name,
-            module: (0, change_case_1.paramCase)(args.module),
-            actions,
-        };
-    },
+// @ts-check
+const { paramCase, pascalCase } = require("change-case");
+
+module.exports = {
+  params: ({ args }) => {
+    const documentModel = JSON.parse(args.documentModel);
+    const latestSpec =
+      documentModel.specifications[documentModel.specifications.length - 1];
+    const filteredModules = latestSpec.modules.filter(
+      (m) => m.name === args.module,
+    );
+
+    const actions =
+      filteredModules.length > 0
+        ? filteredModules[0].operations.map((a) => ({
+            name: a.name,
+            hasInput: a.schema !== null,
+            hasAttachment: a.schema?.includes(": Attachment"),
+            scope: a.scope || "global",
+            state: a.scope === "global" ? "" : a.scope, // the state this action affects
+            errors: a.errors,
+          }))
+        : [];
+
+    const errors = actions.reduce((acc, action) => {
+      action.errors.forEach((error) => {
+        // Fallback: If error code is empty, generate it from the error name in PascalCase
+        const errorCode = error.code || pascalCase(error.name || "");
+        const normalizedError = { ...error, code: errorCode };
+
+        const existingError = acc.find((e) => e.code === errorCode);
+        if (!existingError) {
+          acc.push(normalizedError);
+        } else if (
+          JSON.stringify(existingError) !== JSON.stringify(normalizedError)
+        ) {
+          console.warn(
+            `Warning: Duplicate error code "${errorCode}" with different fields found`,
+          );
+        }
+      });
+      return acc;
+    }, []);
+
+    return {
+      rootDir: args.rootDir,
+      documentType: documentModel.name,
+      module: paramCase(args.module),
+      actions,
+      errors,
+    };
+  },
 };
-//# sourceMappingURL=index.js.map

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

@@ -1,22 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const change_case_1 = require("change-case");
+// @ts-check
+const { paramCase } = 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),
-            })),
-        };
-    },
+  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: paramCase(m.name),
+      })),
+    };
+  },
 };
-exports.default = generateDocumentModelMutations;
-//# sourceMappingURL=index.js.map
+module.exports = generateDocumentModelMutations;

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

@@ -2,49 +2,59 @@
 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 { actions <% modules.forEach(module => { %><% module.operations.forEach(op => { %>, type <%- h.changeCase.pascal(op.name) %>Input<%_ })}); %>, type <%- h.changeCase.pascal(documentType) %>Document } from "../../document-models/<%- h.changeCase.param(documentType) %>/index.js";
+import { setName } from "document-model";
 
-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) => {
+      <%- h.changeCase.pascal(documentType) %>: 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<<%- h.changeCase.pascal(documentType) %>Document>(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<<%- h.changeCase.pascal(documentType) %>Document>(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,
                 };
               }),
             );
@@ -57,47 +67,50 @@ export const getResolvers = (subgraph: Subgraph): Record<string, any> => {
       },
     },
     Mutation: {
-
-      <%- h.changeCase.pascal(documentType) %>_createDocument: async (_: any, args: any) => {
-        const driveId: string = args.driveId || DEFAULT_DRIVE_ID;
-        const docId = generateId();
+      <%- h.changeCase.pascal(documentType) %>_createDocument: async (_: unknown, args: { name: string, driveId?: string }) => {
+        const { driveId, name } = args;
+        const document = await reactor.addDocument("<%- documentTypeId %>");
         
-        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: "<%- documentTypeId %>",
+            }),
+          );
+        }
+
+        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);
+        <%- h.changeCase.pascal(documentType) + '_' + 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<<%- h.changeCase.pascal(documentType) %>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

@@ -17,8 +17,8 @@ Queries: <%= h.changeCase.pascal(documentType) %>
 """
 
 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 +30,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

@@ -3,48 +3,70 @@ to: "<%= rootDir %>/<%= h.changeCase.param(name) %>/components/CreateDocument.ts
 unless_exists: true
 ---
 import { Button } from "@powerhousedao/design-system";
-import { type DocumentModelModule } from "document-model";
+import {
+  isDocumentTypeSupported,
+  showPHModal,
+  useDocumentModelModules,
+  useSelectedDriveId,
+  type VetraDocumentModelModule,
+} from "@powerhousedao/reactor-browser";
 
 interface CreateDocumentProps {
-  documentModels?: DocumentModelModule[];
-  createDocument: (doc: DocumentModelModule) => void;
+  documentTypes?: string[];
 }
 
-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 const CreateDocument = (props: CreateDocumentProps) => {
+  const { documentTypes = [] } = props;
 
-  return doc.documentModel;
-}
+  const selectedDriveId = useSelectedDriveId();
+  const documentModelModules = useDocumentModelModules();
+
+  const filteredDocumentModelModules = documentModelModules?.filter((module) =>
+    isDocumentTypeSupported(module.documentModel.global.id, documentTypes),
+  );
+
+  function handleAddDocument(module: VetraDocumentModelModule) {
+    if (!selectedDriveId) {
+      return;
+    }
+
+    // Display the Create Document modal on the host app
+    showPHModal({
+      type: "createDocument",
+      documentType: module.documentModel.global.id,
+    });
+  }
 
-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);
+        {filteredDocumentModelModules?.map((documentModelModule) => {
           return (
             <Button
-              key={spec.id}
-              color="light"
-              size="small"
-              className="cursor-pointer"
-              title={spec.name}
-              aria-description={spec.description}
-              onClick={() => createDocument(doc)}
+              key={documentModelModule.documentModel.global.id}
+              color="light" // Customize button appearance
+              className="cursor-pointer bg-gray-200 p-2 hover:bg-gray-300"
+              title={documentModelModule.documentModel.global.name}
+              aria-description={documentModelModule.documentModel.global.description}
+              onClick={() => handleAddDocument(documentModelModule)}
             >
-              <span className="text-sm">{spec.name}</span>
+              {/* Customize document type display format */}
+              <span className="text-sm">
+                {documentModelModule.documentModel.global.name}
+              </span>
             </Button>
           );
         })}
       </div>
     </div>
   );
-}; 
+};