@powerhousedao/codegen 4.1.0-dev.7 → 4.1.0-dev.71

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

@@ -2,78 +2,7 @@
 to: "<%= rootDir %>/<%= h.changeCase.param(name) %>/editor.tsx"
 unless_exists: true
 ---
-import { type DriveEditorProps } from "@powerhousedao/reactor-browser";
-import { AnalyticsProvider } from '@powerhousedao/reactor-browser/analytics/context';
-import { DriveContextProvider } from "@powerhousedao/reactor-browser/hooks/useDriveContext";
-import { type DocumentDriveDocument, addFolder, deleteNode, updateNode, generateNodesCopy, copyNode } from "document-drive";
-import { WagmiContext } from "@powerhousedao/design-system";
+import { withDropZone } from "@powerhousedao/design-system";
 import { DriveExplorer } from "./components/DriveExplorer.js";
-import { useCallback } from "react";
-import { generateId } from "document-model";
 
-export type IProps = DriveEditorProps<DocumentDriveDocument>;
-
-export function BaseEditor(props: IProps) {
-  const { dispatch, context } = props;
-  
-  const onAddFolder = useCallback((name: string, parentFolder?: string) => {
-    dispatch(addFolder({
-      id: generateId(),
-      name,
-      parentFolder,
-    }));
-  }, [dispatch]);
-
-  const onDeleteNode = useCallback((nodeId: string) => {
-    dispatch(deleteNode({ id: nodeId }));
-  }, [dispatch]);
-
-  const renameNode = useCallback((nodeId: string, name: string) => {
-    dispatch(updateNode({ id: nodeId, name }));
-  }, [dispatch]);
-
-  const onCopyNode = useCallback((nodeId: string, targetName: string, parentId?: string) => {
-    const copyNodesInput = generateNodesCopy({
-      srcId: nodeId,
-      targetParentFolder: parentId,
-      targetName,
-    }, () => generateId(), props.document.state.global.nodes);
-
-    const copyNodesAction = copyNodesInput.map(input => {
-      return copyNode(input);
-    });
-
-    for (const copyNodeAction of copyNodesAction) {
-      dispatch(copyNodeAction);
-    }
-  }, [dispatch, props.document.state.global.nodes]);
-
-  return (
-    <div
-      className="new-drive-explorer"
-      style={{ height: "100%" }}
-    >
-      <DriveExplorer
-        driveId={props.document.header.id}
-        nodes={props.document.state.global.nodes}
-        onAddFolder={onAddFolder}
-        onDeleteNode={onDeleteNode}
-        renameNode={renameNode}
-        onCopyNode={onCopyNode}
-        context={context}
-      />
-    </div>
-  );
-}
-
-export default function Editor(props: IProps) {
-  return (
-    <DriveContextProvider value={props.context}>
-      <WagmiContext>
-        <AnalyticsProvider databaseName={props.context.analyticsDatabaseName}>
-          <BaseEditor {...props} />
-        </AnalyticsProvider>
-      </WagmiContext>
-    </DriveContextProvider>
-  );
-}
+export const Editor = withDropZone(DriveExplorer);

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

@@ -3,18 +3,19 @@ to: "<%= rootDir %>/<%= h.changeCase.param(name) %>/index.ts"
 force: true
 ---
 import { type DriveEditorModule } from "@powerhousedao/reactor-browser";
-import { type DocumentDriveDocument } from "document-drive";
-import Editor from "./editor.js";
+import { Editor } from "./editor.js";
 
-export const module: DriveEditorModule<DocumentDriveDocument> = {
+export const module: DriveEditorModule = {
   Component: Editor,
   documentTypes: ["powerhouse/document-drive"],
   config: {
-    id: "<%= name %>",
+    id: "<%= appId || 'drive-editor-id' %>",
     disableExternalControls: true,
     documentToolbarEnabled: true,
-    showSwitchboardLink: true,
+    showSwitchboardLink: true,<%_ if (dragAndDropEnabled) { _%>
+    documentTypes: [<%- (dragAndDropDocumentTypes ? JSON.parse(dragAndDropDocumentTypes) : []).map(type => JSON.stringify(type)).join(', ') %>],
+    dragAndDrop: {
+      enabled: true,
+    },<%_ } _%>
   },
 };
-
-export default module;

package/dist/src/codegen/.hygen/templates/powerhouse/generate-drive-editor/index.js

@@ -0,0 +1,12 @@
+// @ts-check
+module.exports = {
+  params: ({ args }) => {
+    return {
+      rootDir: args.rootDir,
+      name: args.name,
+      appId: args.appId,
+      dragAndDropEnabled: args.dragAndDropEnabled,
+      dragAndDropDocumentTypes: args.dragAndDropDocumentTypes,
+    };
+  },
+};

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

@@ -2,25 +2,92 @@
 to: "<%= rootDir %>/<%= h.changeCase.param(name) %>/editor.tsx"
 unless_exists: true
 ---
-<% if(!documentTypes.length){ %>import type { EditorProps, PHDocument } from 'document-model';<% } else { %>import type { EditorProps } from 'document-model';<% } %>
-<% documentTypes.forEach(type => { _%>
-import { type <%= documentTypesMap[type].name %>Document, actions } from "<%= documentTypesMap[type].importPath %>/index.js";
-%><% }); _%>
-import { Button } from '@powerhousedao/design-system';
+import {
+  Button,
+  Form,
+  FormLabel,
+  StringField,
+} from "@powerhousedao/document-engineering";
+<% if(!documentType){ %>import { useSelectedDocument } from "@powerhousedao/reactor-browser";<% } else { %>import { useSelected<%= documentType.name %>Document %>} from "../hooks/use<%= documentType.name %>Document%>.js";<% } %>
+import { setName } from "document-model";<% if(documentType) { %>
+import { actions } from "<%= documentType.importPath %>";<% } %>
 
-export type IProps = <% if(!documentTypes.length){ %>EditorProps<PHDocument><% } else { %><% documentTypes.forEach((type, index) => { _%>EditorProps<<%= documentTypesMap[type].name %>Document%>%>><% if(index < documentTypes.length - 1){ %> | <% }%><% }); _%> <% } %>;
+export function Editor() {
+  const [document, dispatch] = <% if(documentType) { %>useSelected<%= documentType.name %>Document()<% } else { %>useSelectedDocument()<% } %>;
+<% if(!documentType){ %>
+  if (!document) {
+    return null;
+  }
+<% } %>
+  function handleSetName(values: { name: string }) {
+    if (values.name) {
+      dispatch(setName(values.name));
+    }
+  }
 
-export default function Editor(props: IProps) {
-    return (
-        <div>
-            <div className="html-defaults-container">
-                <h1>This h1 will be styled</h1>
-                <p>This paragraph will also be styled.</p>
-                <button>Styled Button</button>
-            </div>
-            <div>
-                <h1>This h1 outside the container will NOT be styled by html-defaults.css</h1>
-            </div>
-        </div>
-    );
-};
+  return (
+    <div className="ph-default-styles py-10 text-center">
+      <div className="inline-flex flex-col gap-10 text-start">
+        
+        {/* Edit document name form */}
+        <section className="flex justify-between">
+          <h1 className="text-start">{document.header.name}</h1>
+          <div className="flex flex-col space-y-2">
+            <Form
+              onSubmit={handleSetName}
+              defaultValues={{ name: document.header.name }}
+              className="flex flex-col gap-3 pt-2"
+            >
+              <div className="flex items-end gap-3">
+                <div>
+                  <FormLabel htmlFor="name">
+                    <b className="mb-1">Change document name</b>
+                  </FormLabel>
+                  <StringField
+                    name="name"
+                    placeholder="Enter document name"
+                    className="mt-1"
+                  />
+                </div>
+                <Button type="submit">Edit</Button>
+              </div>
+            </Form>
+          </div>
+        </section>
+
+        {/* Document metadata */}
+        <section>
+          <ul className="grid grid-cols-2 gap-x-4 gap-y-1 text-gray-700">
+            <li>
+              <b className="mr-1">Id:</b>
+              {document.header.id}
+            </li>
+            <li>
+              <b className="mr-1">Created:</b>
+              {new Date(document.header.createdAtUtcIso).toLocaleString()}
+            </li>
+            <li>
+              <b className="mr-1">Type:</b>
+              {document.header.documentType}
+            </li>
+            <li>
+              <b className="mr-1">Last Modified:</b>
+              {new Date(document.header.lastModifiedAtUtcIso).toLocaleString()}
+            </li>
+          </ul>
+        </section>
+
+        {/* Document state */}
+        <section className="inline-block">
+          <h2 className="mb-4">Document state</h2>
+          <textarea
+            rows={10}
+            readOnly
+            value={JSON.stringify(document.state, null, 2)}
+            className="font-mono"
+          ></textarea>
+        </section>
+      </div>
+    </div>
+  );
+}

package/dist/src/codegen/.hygen/templates/powerhouse/generate-editor/hooks.esm.t

@@ -0,0 +1,16 @@
+---
+to: "<%= documentType ? `${rootDir}/hooks/use${h.changeCase.pascal(documentType.name)}Document.ts` : null %>"
+unless_exists: true
+---
+<% if (documentType) { %>
+import { useDocumentOfType, useSelectedDocumentOfType } from "@powerhousedao/reactor-browser";
+import type { <%= documentType.name %>Action, <%= documentType.name %>Document } from "<%= documentType.importPath %>";
+
+export function use<%= documentType.name %>Document(documentId: string | null | undefined) {
+  return useDocumentOfType<<%= documentType.name %>Document, <%= documentType.name %>Action>(documentId, "<%= documentType.type %>");
+}
+
+export function useSelected<%= documentType.name %>Document() {
+  return useSelectedDocumentOfType<<%= documentType.name %>Document, <%= documentType.name %>Action>("<%= documentType.type %>");
+}
+<% } %>

package/dist/src/codegen/.hygen/templates/powerhouse/generate-editor/index.esm.t

@@ -3,20 +3,15 @@ to: "<%= rootDir %>/<%= h.changeCase.param(name) %>/index.ts"
 force: true
 ---
 import type { EditorModule } from 'document-model';
-import Editor from './editor.js';
-<% documentTypes.forEach(type => { _%>
-import type { <%= documentTypesMap[type].name %>Document } from "<%= documentTypesMap[type].importPath %>/index.js";
-%><% }); _%>
+import { Editor } from './editor.js';
 
-export const module: <% if(!documentTypes.length){ %>EditorModule<% } else { %><% documentTypes.forEach((type, index) => { _%>EditorModule<<%= documentTypesMap[type].name %>Document%>%>> <% if(index < documentTypes.length - 1){ %>| <% }%><% }); _%> <% } %>= {
+export const module: EditorModule = {
     Component: Editor,
     documentTypes: [<% if(!documentTypes.length){ %>'*'<% } else { %><% documentTypes.forEach(type => { _%>"<%= type %>", %><% }); _%> <% } %>],
     config: {
-        id: 'editor-id',
+        id: '<%= editorId || 'editor-id' %>',
         disableExternalControls: true,
         documentToolbarEnabled: true,
         showSwitchboardLink: true,
     },
-};
-
-export default module;
+};

package/dist/src/codegen/.hygen/templates/powerhouse/generate-editor/index.js

@@ -1,16 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = {
-    params: ({ args }) => {
-        return {
-            rootDir: args.rootDir,
-            documentModelsDir: args.documentModelsDir,
-            name: args.name,
-            documentTypes: args.documentTypes
-                .split(",")
-                .filter((type) => type !== ""),
-            documentTypesMap: JSON.parse(args.documentTypesMap),
-        };
-    },
+// @ts-check
+module.exports = {
+  params: ({ args }) => {
+    const documentTypes = args.documentTypes
+      .split(",")
+      .map((type) => type.trim())
+      .filter((type) => type !== "");
+    const documentTypesMap = JSON.parse(args.documentTypesMap);
+
+    // if this editor is for a single document type, then the boilerplate will be customized to it
+    const singleDocumentType =
+      documentTypes.length === 1 ? documentTypes[0] : undefined;
+    const documentType = singleDocumentType
+      ? { ...documentTypesMap[singleDocumentType], type: singleDocumentType }
+      : undefined;
+
+    return {
+      rootDir: args.rootDir,
+      documentModelsDir: args.documentModelsDir,
+      name: args.name,
+      documentTypes: args.documentTypes
+        .split(",")
+        .filter((type) => type !== ""),
+      documentTypesMap,
+      editorId: args.editorId,
+      documentType,
+    };
+  },
 };
-//# sourceMappingURL=index.js.map

package/dist/src/codegen/.hygen/templates/powerhouse/generate-import-script/index.js

@@ -1,11 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = {
-    params: ({ args }) => {
-        return {
-            rootDir: args.rootDir,
-            name: args.name,
-        };
-    },
+// @ts-check
+module.exports = {
+  params: ({ args }) => {
+    return {
+      rootDir: args.rootDir,
+      name: args.name,
+    };
+  },
 };
-//# sourceMappingURL=index.js.map

package/dist/src/codegen/.hygen/templates/powerhouse/generate-processor-analytics/factory.esm.t

@@ -1,12 +1,13 @@
 ---
 to: "<%= rootDir %>/<%= h.changeCase.param(name) %>/factory.ts"
-force: true
+unless_exists: true
 ---
-import { type ProcessorRecord } from "document-drive/processors/types";
-import { type IProcessorHostModule } from "document-drive/processors/types";
+import { type ProcessorRecord } from "document-drive";
+import { type IProcessorHostModule } from "document-drive";
+import { type PHDocumentHeader } from "document-model";
 import { <%= pascalName %>Processor } from "./index.js";
 
-export const <%= h.changeCase.pascal(name) %>ProcessorFactory = (module: IProcessorHostModule) => (driveId: string): ProcessorRecord[] => {
+export const <%= h.changeCase.pascal(name) %>ProcessorFactory = (module: IProcessorHostModule) => (driveHeader: PHDocumentHeader): ProcessorRecord[] => {
   return [
     {
       processor: new <%= pascalName %>Processor(module.analyticsStore),

package/dist/src/codegen/.hygen/templates/powerhouse/generate-processor-analytics/index.esm.t

@@ -1,14 +1,10 @@
 ---
 to: "<%= rootDir %>/<%= h.changeCase.param(name) %>/index.ts"
-force: true
+unless_exists: true
 ---
-import type { PHDocument } from "document-model";
-import { AnalyticsPath, AnalyticsSeriesInput, IAnalyticsStore } from "@powerhousedao/reactor-api";
-import { InternalTransmitterUpdate, IProcessor } from "document-drive";
-
-<% documentTypes.forEach(type => { _%>
-import type { <%= documentTypesMap[type].name %>Document } from "<%= documentTypesMap[type].importPath %>/index.js";
-%><% }); _%>
+import type { AnalyticsSeriesInput, IAnalyticsStore } from "@powerhousedao/analytics-engine-core";
+import { AnalyticsPath } from "@powerhousedao/analytics-engine-core";
+import type { InternalTransmitterUpdate, IProcessor } from "document-drive";
 
 export class <%= pascalName %>Processor implements IProcessor {
   private readonly NAMESPACE = "<%= pascalName %>";
@@ -19,7 +15,7 @@ export class <%= pascalName %>Processor implements IProcessor {
     //
   }
 
-  async onStrands<TDocument extends PHDocument>(strands: InternalTransmitterUpdate<TDocument>[]): Promise<void> {
+  async onStrands(strands: InternalTransmitterUpdate[]): Promise<void> {
     if (strands.length === 0) {
       return;
     }

package/dist/src/codegen/.hygen/templates/powerhouse/generate-processor-analytics/index.js

@@ -1,16 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = {
-    params: ({ args }) => {
-        return {
-            rootDir: args.rootDir,
-            documentModelsDir: args.documentModelsDir,
-            name: args.name,
-            documentTypes: args.documentTypes
-                .split(",")
-                .filter((type) => type !== ""),
-            documentTypesMap: JSON.parse(args.documentTypesMap),
-        };
-    },
+// @ts-check
+module.exports = {
+  params: ({ args }) => {
+    return {
+      rootDir: args.rootDir,
+      documentModelsDir: args.documentModelsDir,
+      name: args.name,
+      documentTypes: args.documentTypes
+        .split(",")
+        .filter((type) => type !== ""),
+      documentTypesMap: JSON.parse(args.documentTypesMap),
+    };
+  },
 };
-//# sourceMappingURL=index.js.map

package/dist/src/codegen/.hygen/templates/powerhouse/generate-processor-analytics/lib.esm.t

@@ -7,24 +7,26 @@ unless_exists: true
  * Auto-generated by codegen - DO NOT EDIT MANUALLY
  */
 
-import { type ProcessorRecord } from "document-drive/processors/types";
-import { type IProcessorHostModule } from "document-drive/processors/types";
+import { type ProcessorRecord, type ProcessorFactory } from "document-drive";
+import { type IProcessorHostModule } from "document-drive";
+import { type PHDocumentHeader } from "document-model";
 
 // Import processor factories here as they are generated
 
 export const processorFactory = (module: IProcessorHostModule) => {
   // Initialize all processor factories once with the module
-  const factories: Array<(driveId: string) => ProcessorRecord[]> = [];
+  const factories: Array<ProcessorFactory> = [];
   
   // Add processors here as they are generated
   
   // Return the inner function that will be called for each drive
-  return (driveId: string): ProcessorRecord[] => {
+  return async (driveHeader: PHDocumentHeader): Promise<ProcessorRecord[]> => {
     const processors: ProcessorRecord[] = [];
     
-    // Call each cached factory with the driveId
+    // Call each cached factory with the driveHeader
     for (const factory of factories) {
-      processors.push(...factory(driveId));
+      const factoryProcessors = await factory(driveHeader);
+      processors.push(...factoryProcessors);
     }
     
     return processors;

package/dist/src/codegen/.hygen/templates/powerhouse/generate-processor-analytics/lib.inject_call.esm.t

@@ -2,6 +2,6 @@
 inject: true
 to: "<%= rootDir %>/factory.ts"
 after: "  // Add processors here as they are generated"
-skip_if: "<%=h.changeCase.pascal(name) %>ProcessorFactory(module)"
+skip_if: "<%= h.changeCase.pascal(name) %>ProcessorFactory"
 ---
   factories.push(<%= h.changeCase.pascal(name) %>ProcessorFactory(module));

package/dist/src/codegen/.hygen/templates/powerhouse/generate-processor-analytics/lib.inject_import.esm.t

@@ -2,6 +2,6 @@
 inject: true
 to: "<%= rootDir %>/factory.ts"
 after: "// Import processor factories here as they are generated"
-skip_if: "{ <%= h.changeCase.camel(name) %>ProcessorFactory }"
+skip_if: "{ <%= h.changeCase.pascal(name) %>ProcessorFactory }"
 ---
 import { <%= h.changeCase.pascal(name) %>ProcessorFactory } from "./<%= h.changeCase.param(name) %>/factory.js";

package/dist/src/codegen/.hygen/templates/powerhouse/generate-processor-relationalDb/factory.esm.t

@@ -1,19 +1,20 @@
 ---
 to: "<%= rootDir %>/<%= h.changeCase.param(name) %>/factory.ts"
-force: true
+unless_exists: true
 ---
 import {
   type ProcessorRecord,
   type IProcessorHostModule
-} from "document-drive/processors/types";
+} from "document-drive";
 import {
   type RelationalDbProcessorFilter,
-} from "document-drive/processors/relational";
+} from "document-drive";
+import { type PHDocumentHeader } from "document-model";
 import { <%= pascalName %>Processor } from "./index.js";
 
-export const <%= h.changeCase.camel(name) %>ProcessorFactory = (module: IProcessorHostModule) => async (driveId: string): Promise<ProcessorRecord[]> => {
+export const <%= h.changeCase.camel(name) %>ProcessorFactory = (module: IProcessorHostModule) => async (driveHeader: PHDocumentHeader): Promise<ProcessorRecord[]> => {
   // Create a namespace for the processor and the provided drive id
-  const namespace = <%= pascalName %>Processor.getNamespace(driveId);
+  const namespace = <%= pascalName %>Processor.getNamespace(driveHeader.id);
 
   // Create a namespaced db for the processor
   const store = await module.relationalDb.createNamespace<<%= pascalName %>Processor>(

package/dist/src/codegen/.hygen/templates/powerhouse/generate-processor-relationalDb/index.esm.t

@@ -1,19 +1,17 @@
 ---
 to: "<%= rootDir %>/<%= h.changeCase.param(name) %>/index.ts"
-force: true
+unless_exists: true
 ---
-import { type IRelationalDb } from "document-drive/processors/types";
-import { RelationalDbProcessor } from "document-drive/processors/relational";
-import { type InternalTransmitterUpdate } from "document-drive/server/listener/transmitter/internal";
+import { type IRelationalDb } from "document-drive";
+import { RelationalDbProcessor } from "document-drive";
+import { type InternalTransmitterUpdate } from "document-drive";
 <% documentTypes.forEach(type => { _%>
-import type { <%= documentTypesMap[type].name %>Document } from "<%= documentTypesMap[type].importPath %>/index.js";
+import type { <%= documentTypesMap[type].name %>Document } from "<%= documentTypesMap[type].importPath %>";
 %><% }); _%>
 <% if(documentTypes.length === 0) { %>import { type PHDocument } from "document-model";<% } %>
 import { up } from "./migrations.js";
 import { type DB } from "./schema.js";
 
-type DocumentType = <% if(documentTypes.length) { %><%= documentTypes.map(type => `${documentTypesMap[type].name}Document`).join(" | ") %> <% } else { %>PHDocument<% } %>;
-
 export class <%= pascalName %>Processor extends RelationalDbProcessor<DB> {
   static override getNamespace(driveId: string): string {
     // Default namespace: `${this.name}_${driveId.replaceAll("-", "_")}`
@@ -25,7 +23,7 @@ export class <%= pascalName %>Processor extends RelationalDbProcessor<DB> {
   }
 
   override async onStrands(
-    strands: InternalTransmitterUpdate<DocumentType>[],
+    strands: InternalTransmitterUpdate[],
   ): Promise<void> {
     if (strands.length === 0) {
       return;
@@ -40,7 +38,7 @@ export class <%= pascalName %>Processor extends RelationalDbProcessor<DB> {
         await this.relationalDb
           .insertInto("todo")
           .values({
-            task: `${strand.documentId}-${operation.index}: ${operation.type}`,
+            task: `${strand.documentId}-${operation.index}: ${operation.action.type}`,
             status: true,
           })
           .onConflict((oc) => oc.column("task").doNothing())

package/dist/src/codegen/.hygen/templates/powerhouse/generate-processor-relationalDb/index.js

@@ -1,16 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = {
-    params: ({ args }) => {
-        return {
-            rootDir: args.rootDir,
-            documentModelsDir: args.documentModelsDir,
-            name: args.name,
-            documentTypes: args.documentTypes
-                .split(",")
-                .filter((type) => type !== ""),
-            documentTypesMap: JSON.parse(args.documentTypesMap),
-        };
-    },
+// @ts-check
+module.exports = {
+  params: ({ args }) => {
+    return {
+      rootDir: args.rootDir,
+      documentModelsDir: args.documentModelsDir,
+      name: args.name,
+      documentTypes: args.documentTypes
+        .split(",")
+        .filter((type) => type !== ""),
+      documentTypesMap: JSON.parse(args.documentTypesMap),
+    };
+  },
 };
-//# sourceMappingURL=index.js.map

package/dist/src/codegen/.hygen/templates/powerhouse/generate-processor-relationalDb/lib.esm.t

@@ -7,25 +7,24 @@ unless_exists: true
  * Auto-generated by codegen - DO NOT EDIT MANUALLY
  */
 
-import { type ProcessorRecord, type IProcessorHostModule } from "document-drive/processors/types";
+import { type ProcessorRecord, type IProcessorHostModule, type ProcessorFactory } from "document-drive";
+import { type PHDocumentHeader } from "document-model";
 
-// Import other processor factories here as they are generated
+// Import processor factories here as they are generated
 
 export const processorFactory = (module: IProcessorHostModule) => {
   // Initialize all processor factories once with the module
-  const factories: Array<(driveId: string) => Promise<ProcessorRecord[]>> = [];
+  const factories: Array<ProcessorFactory> = [];
   
-  // Add all processor factories
-  
-  // Add other processors here as they are generated
+  // Add processors here as they are generated
   
   // Return the inner function that will be called for each drive
-  return async (driveId: string): Promise<ProcessorRecord[]> => {
+  return async (driveHeader: PHDocumentHeader): Promise<ProcessorRecord[]> => {
     const processors: ProcessorRecord[] = [];
     
-    // Call each cached factory with the driveId
+    // Call each cached factory with the driveHeader
     for (const factory of factories) {
-      const factoryProcessors = await factory(driveId);
+      const factoryProcessors = await factory(driveHeader);
       processors.push(...factoryProcessors);
     }
     

package/dist/src/codegen/.hygen/templates/powerhouse/generate-processor-relationalDb/lib.inject_call.esm.t

@@ -1,7 +1,7 @@
 ---
 inject: true
 to: "<%= rootDir %>/factory.ts"
-after: "  // Add other processors here as they are generated"
-skip_if: "<%=h.changeCase.camel(name) %>ProcessorFactory(module)"
+after: "  // Add processors here as they are generated"
+skip_if: "<%= h.changeCase.camel(name) %>ProcessorFactory"
 ---
   factories.push(<%= h.changeCase.camel(name) %>ProcessorFactory(module));

package/dist/src/codegen/.hygen/templates/powerhouse/generate-processor-relationalDb/lib.inject_import.esm.t

@@ -1,7 +1,7 @@
 ---
 inject: true
 to: "<%= rootDir %>/factory.ts"
-after: "// Import other processor factories here as they are generated"
+after: "// Import processor factories here as they are generated"
 skip_if: "{ <%= h.changeCase.camel(name) %>ProcessorFactory }"
 ---
 import { <%= h.changeCase.camel(name) %>ProcessorFactory } from "./<%= h.changeCase.param(name) %>/factory.js";

package/dist/src/codegen/.hygen/templates/powerhouse/generate-processor-relationalDb/migrations.esm.t

@@ -1,8 +1,8 @@
 ---
 to: "<%= rootDir %>/<%= h.changeCase.param(name) %>/migrations.ts"
-force: true
+unless_exists: true
 ---
-import { type IRelationalDb } from "document-drive/processors/types"
+import { type IRelationalDb } from "document-drive"
 
 export async function up(db: IRelationalDb<any>): Promise<void> {
   // Create table