@powerhousedao/codegen 5.0.3 → 5.0.4

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

@@ -1,13 +1,13 @@
 ---
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/actions.ts"
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/actions.ts"
 force: true
 ---
 <% modules.forEach(module => { _%>
-import type { <%= h.changeCase.pascal(documentType) %><%= h.changeCase.pascal(module.name) %>Action } from './<%= module.name %>/actions.js';
+import type { <%= h.changeCase.pascal(documentType) %><%= h.changeCase.pascal(module.name) %>Action } from './<%= h.changeCase.param(module.name) %>/actions.js';
 <% }); _%>
 
 <% modules.forEach(module => { _%>
-export * from './<%= module.name %>/actions.js';
+export * from './<%= h.changeCase.param(module.name) %>/actions.js';
 <% }); _%>
 
 export <%= 'type ' + h.changeCase.pascal(documentType) %>Action =

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

@@ -1,8 +1,9 @@
 ---
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/creators.ts"
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/creators.ts"
 force: true
 ---
 
 <% modules.forEach(module => { _%>
-export * from './<%= module.name %>/creators.js';
+export * from "./<%= h.changeCase.param(module.name) %>/creators.js";
+export * as <%= h.changeCase.camel(module.name) %>Actions from "./<%= h.changeCase.param(module.name) %>/creators.js";
 <% }); _%>

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

@@ -1,5 +1,5 @@
 ---
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/src/utils.ts"
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/src/utils.ts"
 unless_exists: true
 ---
 export {};

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

@@ -0,0 +1,14 @@
+---
+force: true
+to: "<%= rootDir %>/document-models.ts"
+---
+import type { DocumentModelModule } from "document-model";
+<% moduleExports.forEach(me => { _%>
+import { <%= me.pascalCaseName %> } from "./<%= me.paramCaseName %>/module.js";
+<% }); _%>
+
+export const documentModels: DocumentModelModule<any>[] = [
+  <% moduleExports.forEach(me => { _%>
+<%= me.pascalCaseName %>,
+<% }); _%>
+]

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

@@ -0,0 +1,56 @@
+---
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/document-schema.ts"
+force: true
+---
+import {
+  BaseDocumentHeaderSchema,
+  BaseDocumentStateSchema,
+} from "document-model";
+import { z } from "zod";
+import { <%= documentTypeVariableName %> } from "./document-type.js";
+import { <%= stateSchemaName %> } from "./schema/zod.js";
+import type { <%= phDocumentTypeName %>, <%= phStateName %> } from "./types.js";
+
+/** Schema for validating the header object of a <%= pascalCaseDocumentType %> document */
+export const <%= phDocumentTypeName %>HeaderSchema = BaseDocumentHeaderSchema.extend({
+  documentType: z.literal(<%= documentTypeVariableName %>),
+});
+
+/** Schema for validating the state object of a <%= pascalCaseDocumentType %> document */
+export const <%= phStateName %>Schema = BaseDocumentStateSchema.extend({
+  global: <%= stateSchemaName %>(),
+});
+
+export const <%= phDocumentSchemaName %> = z.object({
+  header: <%= phDocumentTypeName %>HeaderSchema,
+  state: <%= phStateName %>Schema,
+  initialState: <%= phStateName %>Schema,
+});
+
+/** Simple helper function to check if a state object is a <%= pascalCaseDocumentType %> document state object */
+export function <%= isPhStateOfTypeFunctionName %>(
+  state: unknown,
+): state is <%= phStateName %> {
+  return <%= phStateName %>Schema.safeParse(state).success;
+}
+
+/** Simple helper function to assert that a document state object is a <%= pascalCaseDocumentType %> document state object */
+export function <%= assertIsPhStateOfTypeFunctionName %>(
+  state: unknown,
+): asserts state is <%= phStateName %> {
+  <%= phStateName %>Schema.parse(state);
+}
+
+/** Simple helper function to check if a document is a <%= pascalCaseDocumentType %> document */
+export function <%= isPhDocumentOfTypeFunctionName %>(
+  document: unknown,
+): document is <%= phDocumentTypeName %> {
+  return <%= phDocumentSchemaName %>.safeParse(document).success;
+}
+
+/** Simple helper function to assert that a document is a <%= pascalCaseDocumentType %> document */
+export function <%= assertIsPhDocumentOfTypeFunctionName %>(
+  document: unknown,
+): asserts document is <%= phDocumentTypeName %> {
+  <%= phDocumentSchemaName %>.parse(document);
+}

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

@@ -0,0 +1,6 @@
+---
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/document-type.ts"
+force: true
+---
+
+export const <%= documentTypeVariableName %> = "<%= documentTypeId %>";

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

@@ -1,5 +1,5 @@
 ---
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/document-model.ts"
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/document-model.ts"
 force: true
 ---
 import type { DocumentModelGlobalState } from "document-model";

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

@@ -1,26 +1,121 @@
 ---
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/src/tests/document-model.test.ts"
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/src/tests/document-model.test.ts"
 unless_exists: true
 ---
 /**
  * This is a scaffold file meant for customization:
  * - change it by adding new tests or modifying the existing ones
  */
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  utils,
+  initialGlobalState,
+  initialLocalState,
+  <%= documentTypeVariableName %>,
+  <%= isPhDocumentOfTypeFunctionName %>,
+  <%= assertIsPhDocumentOfTypeFunctionName %>,
+  <%= isPhStateOfTypeFunctionName %>,
+  <%= assertIsPhStateOfTypeFunctionName %>,
+} from "<%= documentModelDir %>";
+import { ZodError } from "zod";
+
+describe("<%= pascalCaseDocumentType %> Document Model", () => {
+  it("should create a new <%= pascalCaseDocumentType %> document", () => {
+    const document = utils.createDocument();
+
+    expect(document).toBeDefined();
+    expect(document.header.documentType).toBe(<%= documentTypeVariableName %>);
+  });
+
+  it("should create a new <%= pascalCaseDocumentType %> document with a valid initial state", () => {
+    const document = utils.createDocument();
+    expect(document.state.global).toStrictEqual(initialGlobalState);
+    expect(document.state.local).toStrictEqual(initialLocalState);
+    expect(<%= isPhDocumentOfTypeFunctionName %>(document)).toBe(true);
+    expect(<%= isPhStateOfTypeFunctionName %>(document.state)).toBe(true);
+  });
+  it("should reject a document that is not a <%= pascalCaseDocumentType %> document", () => {
+    const wrongDocumentType = utils.createDocument();
+    wrongDocumentType.header.documentType = "the-wrong-thing-1234";
+    try {
+      expect(<%= assertIsPhDocumentOfTypeFunctionName %>(wrongDocumentType)).toThrow();
+      expect(<%= isPhDocumentOfTypeFunctionName %>(wrongDocumentType)).toBe(false);
+    } catch (error) {
+      expect(error).toBeInstanceOf(ZodError);
+    }
+  });
+  const wrongState = utils.createDocument();
+  // @ts-expect-error - we are testing the error case
+  wrongState.state.global = {
+    ...{ notWhat: "you want" },
+  };
+  try {
+    expect(<%= isPhStateOfTypeFunctionName %>(wrongState.state)).toBe(false);
+    expect(<%= assertIsPhStateOfTypeFunctionName %>(wrongState.state)).toThrow();
+    expect(<%= isPhDocumentOfTypeFunctionName %>(wrongState)).toBe(false);
+    expect(<%= assertIsPhDocumentOfTypeFunctionName %>(wrongState)).toThrow();
+  } catch (error) {
+    expect(error).toBeInstanceOf(ZodError);
+  }
+
+  const wrongInitialState = utils.createDocument();
+  // @ts-expect-error - we are testing the error case
+  wrongInitialState.initialState.global = {
+    ...{ notWhat: "you want" },
+  };
+  try {
+    expect(<%= isPhStateOfTypeFunctionName %>(wrongInitialState.state)).toBe(false);
+    expect(<%= assertIsPhStateOfTypeFunctionName %>(wrongInitialState.state)).toThrow();
+    expect(<%= isPhDocumentOfTypeFunctionName %>(wrongInitialState)).toBe(false);
+    expect(<%= assertIsPhDocumentOfTypeFunctionName %>(wrongInitialState)).toThrow();
+  } catch (error) {
+    expect(error).toBeInstanceOf(ZodError);
+  }
 
-import { describe, it, expect, beforeEach } from 'vitest';
-import utils, { initialGlobalState, initialLocalState } from '../../gen/utils.js';
+  const missingIdInHeader = utils.createDocument();
+  // @ts-expect-error - we are testing the error case
+  delete missingIdInHeader.header.id;
+  try {
+    expect(<%= isPhDocumentOfTypeFunctionName %>(missingIdInHeader)).toBe(false);
+    expect(<%= assertIsPhDocumentOfTypeFunctionName %>(missingIdInHeader)).toThrow();
+  } catch (error) {
+    expect(error).toBeInstanceOf(ZodError);
+  }
 
-describe('<%= h.changeCase.title(documentType) %> Document Model', () => {
-    it('should create a new <%= h.changeCase.title(documentType) %> document', () => {
-        const document = utils.createDocument();
+  const missingNameInHeader = utils.createDocument();
+  // @ts-expect-error - we are testing the error case
+  delete missingNameInHeader.header.name;
+  try {
+    expect(<%= isPhDocumentOfTypeFunctionName %>(missingNameInHeader)).toBe(false);
+    expect(<%= assertIsPhDocumentOfTypeFunctionName %>(missingNameInHeader)).toThrow();
+  } catch (error) {
+    expect(error).toBeInstanceOf(ZodError);
+  }
 
-        expect(document).toBeDefined();
-        expect(document.header.documentType).toBe('<%- documentTypeId %>');
-    });
+  const missingCreatedAtUtcIsoInHeader = utils.createDocument();
+  // @ts-expect-error - we are testing the error case
+  delete missingCreatedAtUtcIsoInHeader.header.createdAtUtcIso;
+  try {
+    expect(<%= isPhDocumentOfTypeFunctionName %>(missingCreatedAtUtcIsoInHeader)).toBe(false);
+    expect(<%= assertIsPhDocumentOfTypeFunctionName %>(missingCreatedAtUtcIsoInHeader)).toThrow();
+  } catch (error) {
+    expect(error).toBeInstanceOf(ZodError);
+  }
 
-    it('should create a new <%= h.changeCase.title(documentType) %> document with a valid initial state', () => {
-        const document = utils.createDocument();
-        expect(document.state.global).toStrictEqual(initialGlobalState);
-        expect(document.state.local).toStrictEqual(initialLocalState);
-    });
-});
+  const missingLastModifiedAtUtcIsoInHeader = utils.createDocument();
+  // @ts-expect-error - we are testing the error case
+  delete missingLastModifiedAtUtcIsoInHeader.header.lastModifiedAtUtcIso;
+  try {
+    expect(<%= isPhDocumentOfTypeFunctionName %>(missingLastModifiedAtUtcIsoInHeader)).toBe(false);
+    expect(
+      <%= assertIsPhDocumentOfTypeFunctionName %>(missingLastModifiedAtUtcIsoInHeader),
+    ).toThrow();
+  } catch (error) {
+    expect(error).toBeInstanceOf(ZodError);
+  }
+});

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

@@ -0,0 +1,49 @@
+---
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/hooks.ts"
+force: true
+---
+
+import type { DocumentDispatch } from "@powerhousedao/reactor-browser";
+import {
+  useDocumentsInSelectedDrive,
+  useDocumentsInSelectedFolder,
+  useDocumentById,
+  useSelectedDocument,
+} from "@powerhousedao/reactor-browser";
+import type {
+  <%= phDocumentTypeName %>,
+  <%= actionTypeName %>,
+} from "<%= documentModelDir %>";
+import { <%= isPhDocumentOfTypeFunctionName %> } from "./gen/document-schema.js";
+
+/** Hook to get a <%= pascalCaseDocumentType %> document by its id */
+export function <%= useByIdHookName %>(
+  documentId: string | null | undefined,
+):
+  | [<%= phDocumentTypeName %>, DocumentDispatch<<%= actionTypeName %>>]
+  | [undefined, undefined] {
+  const [document, dispatch] = useDocumentById(documentId);
+  if (!<%= isPhDocumentOfTypeFunctionName %>(document)) return [undefined, undefined];
+  return [document, dispatch];
+}
+
+/** Hook to get the selected <%= pascalCaseDocumentType %> document */
+export function <%= useSelectedHookName %>():
+  | [<%= phDocumentTypeName %>, DocumentDispatch<<%= actionTypeName %>>]
+  | [undefined, undefined] {
+  const [document, dispatch] = useSelectedDocument();
+  if (!<%= isPhDocumentOfTypeFunctionName %>(document)) return [undefined, undefined];
+  return [document, dispatch];
+}
+
+/** Hook to get all <%= pascalCaseDocumentType %> documents in the selected drive */
+export function <%= useInSelectedDriveHookName %>() {
+  const documentsInSelectedDrive = useDocumentsInSelectedDrive();
+  return documentsInSelectedDrive?.filter(<%= isPhDocumentOfTypeFunctionName %>);
+}
+
+/** Hook to get all <%= pascalCaseDocumentType %> documents in the selected folder */
+export function <%= useInSelectedFolderHookName %>() {
+  const documentsInSelectedFolder = useDocumentsInSelectedFolder();
+  return documentsInSelectedFolder?.filter(<%= isPhDocumentOfTypeFunctionName %>);
+}

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

@@ -1,15 +1,23 @@
 ---
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/index.ts"
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/index.ts"
 force: true
 ---
 export * from './actions.js';
 export * from './document-model.js';
 export * from './types.js';
-export * as actions from './creators.js';
+export * from './creators.js';
 export {
-  create<%= h.changeCase.pascal(documentType) %>Document,
+  create<%= phDocumentTypeName %>,
   createState,
   defaultPHState,
   defaultGlobalState,
   defaultLocalState,
-} from './ph-factories.js';
+} from './ph-factories.js';
+export * from "./utils.js";
+export * from "./reducer.js";
+export * from "./schema/index.js";
+export * from "./document-type.js";
+export * from "./document-schema.js";
+<% modules.forEach(module => { _%>
+export * from './<%= h.changeCase.param(module.name) %>/operations.js';
+<% }); _%>

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

@@ -1,6 +1,6 @@
 // @ts-check
-const { paramCase } = require("change-case");
-
+const { paramCase, pascalCase, camelCase } = require("change-case");
+const { getModuleExports } = require("../utils.js");
 function documentModelToString(documentModel) {
   return JSON.stringify(
     {
@@ -31,18 +31,77 @@ module.exports = {
     const documentModel = JSON.parse(args.documentModel);
     const latestSpec =
       documentModel.specifications[documentModel.specifications.length - 1];
-
+    const documentType = documentModel.name;
+    const documentTypeId = documentModel.id;
+    const rootDir = args.rootDir;
+    const paramCaseDocumentType = paramCase(documentType);
+    const pascalCaseDocumentType = pascalCase(documentType);
+    const camelCaseDocumentType = camelCase(documentType);
+    const documentTypeVariableName = `${camelCaseDocumentType}DocumentType`;
+    const stateName = `${pascalCaseDocumentType}State`;
+    const globalStateName = `${pascalCaseDocumentType}GlobalState`;
+    const localStateName = `${pascalCaseDocumentType}LocalState`;
+    const phStateName = `${pascalCaseDocumentType}PHState`;
+    const phDocumentTypeName = `${pascalCaseDocumentType}Document`;
+    const actionTypeName = `${pascalCaseDocumentType}Action`;
+    const actionsTypeName = `${actionTypeName}s`;
+    const actionsName = camelCase(actionsTypeName);
+    const packageName = args.packageName;
+    const documentModelDir = `${packageName}/document-models/${paramCaseDocumentType}`;
+    const stateSchemaName = `${stateName}Schema`;
+    const phDocumentSchemaName = `${phDocumentTypeName}Schema`;
+    const isPhStateOfTypeFunctionName = `is${stateName}`;
+    const assertIsPhStateOfTypeFunctionName = `assertIs${stateName}`;
+    const isPhDocumentOfTypeFunctionName = `is${phDocumentTypeName}`;
+    const assertIsPhDocumentOfTypeFunctionName = `assertIs${phDocumentTypeName}`;
+    const useByIdHookName = `use${phDocumentTypeName}ById`;
+    const useSelectedHookName = `useSelected${phDocumentTypeName}`;
+    const useInSelectedDriveHookName = `use${phDocumentTypeName}sInSelectedDrive`;
+    const useInSelectedFolderHookName = `use${phDocumentTypeName}sInSelectedFolder`;
+    const moduleExports = getModuleExports(
+      rootDir,
+      /export\s+const\s+(\w+)\s*:\s*DocumentModelModule\s*<[^>]*>\s*=/,
+      {
+        paramCaseName: paramCaseDocumentType,
+        pascalCaseName: pascalCaseDocumentType,
+      },
+    );
     return {
-      rootDir: args.rootDir,
+      rootDir,
+      packageName,
+      useByIdHookName,
+      useSelectedHookName,
+      useInSelectedDriveHookName,
+      useInSelectedFolderHookName,
       documentModel: documentModelToString(documentModel),
-      documentTypeId: documentModel.id,
-      documentType: documentModel.name,
+      documentTypeVariableName,
+      documentTypeId,
+      documentType,
+      camelCaseDocumentType,
+      paramCaseDocumentType,
+      pascalCaseDocumentType,
+      stateName,
+      globalStateName,
+      localStateName,
+      phDocumentTypeName,
+      phStateName,
+      actionTypeName,
+      actionsTypeName,
+      actionsName,
+      stateSchemaName,
+      phDocumentSchemaName,
+      isPhDocumentOfTypeFunctionName,
+      assertIsPhDocumentOfTypeFunctionName,
+      isPhStateOfTypeFunctionName,
+      assertIsPhStateOfTypeFunctionName,
+      documentModelDir,
       extension: documentModel.extension,
       modules: latestSpec.modules.map((m) => ({
         ...m,
         name: paramCase(m.name),
       })),
-      fileExtension: documentModel.extension,
+      moduleExports,
+      fileExtension: documentModel.extension || "",
       hasLocalSchema: latestSpec.state.local.schema !== "",
       ...getInitialStates(latestSpec.state),
     };

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

@@ -1,9 +1,11 @@
 ---
 to: "<%= rootDir %>/index.ts"
-unless_exists: true
+force: true
 ---
 /**
 * This is a scaffold file meant for customization.
 * Delete the file and run the code generator again to have it reset
 */
-
+<% moduleExports.forEach(me => { _%>
+export { <%= me.pascalCaseName %> } from "./<%= me.paramCaseName %>/module.js";
+<% }); _%>

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

@@ -0,0 +1,22 @@
+---
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/module.ts"
+force: true
+---
+import type { DocumentModelModule } from "document-model";
+import { createState } from "document-model";
+import { defaultBaseState } from "document-model/core";
+import type { <%= phStateName %> } from "<%= documentModelDir %>";
+import {
+  actions,
+  documentModel,
+  reducer,
+  utils,
+} from "<%= documentModelDir %>";
+
+/** Document model module for the Todo List document type */
+export const <%= pascalCaseDocumentType %>: DocumentModelModule<<%= phStateName %>> = {
+  reducer,
+  actions,
+  utils,
+  documentModel: createState(defaultBaseState(), documentModel),
+};

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/ph-factories.esm.t

@@ -1,9 +1,9 @@
 ---
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/ph-factories.ts"
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/ph-factories.ts"
 force: true
 ---
 /**
- * Factory methods for creating <%= h.changeCase.pascal(documentType) %>Document instances
+ * Factory methods for creating <%= phDocumentTypeName %> instances
  */
 import type {
   PHAuthState,
@@ -15,22 +15,22 @@ import {
   defaultBaseState,
 } from "document-model/core";
 import type {
-  <%= h.changeCase.pascal(documentType) %>Document,
-  <%= h.changeCase.pascal(documentType) %>LocalState,
-  <%= h.changeCase.pascal(documentType) %>GlobalState,
-  <%= h.changeCase.pascal(documentType) %>PHState,
+  <%= phDocumentTypeName %>,
+  <%= localStateName %>,
+  <%= globalStateName %>,
+  <%= phStateName %>,
 } from "./types.js";
 import { createDocument } from "./utils.js";
 
-export function defaultGlobalState(): <%= h.changeCase.pascal(documentType) %>GlobalState {
+export function defaultGlobalState(): <%= globalStateName %> {
   return <%- initialGlobalState %>;
 }
 
-export function defaultLocalState(): <%= h.changeCase.pascal(documentType) %>LocalState {
+export function defaultLocalState(): <%= localStateName %> {
   return <%- initialLocalState %>;
 }
 
-export function defaultPHState(): <%= h.changeCase.pascal(documentType) %>PHState {
+export function defaultPHState(): <%= phStateName %> {
   return {
     ...defaultBaseState(),
     global: defaultGlobalState(),
@@ -39,28 +39,28 @@ export function defaultPHState(): <%= h.changeCase.pascal(documentType) %>PHStat
 }
 
 export function createGlobalState(
-  state?: Partial<<%= h.changeCase.pascal(documentType) %>GlobalState>,
-): <%= h.changeCase.pascal(documentType) %>GlobalState {
+  state?: Partial<<%= globalStateName %>>,
+): <%= globalStateName %> {
   return {
     ...defaultGlobalState(),
     ...(state || {}),
-  } as <%= h.changeCase.pascal(documentType) %>GlobalState;
+  } as <%= globalStateName %>;
 }
 
 export function createLocalState(
-  state?: Partial<<%= h.changeCase.pascal(documentType) %>LocalState>,
-): <%= h.changeCase.pascal(documentType) %>LocalState {
+  state?: Partial<<%= localStateName %>>,
+): <%= localStateName %> {
   return {
     ...defaultLocalState(),
     ...(state || {}),
-  } as <%= h.changeCase.pascal(documentType) %>LocalState;
+  } as <%= localStateName %>;
 }
 
 export function createState(
   baseState?: Partial<PHBaseState>,
-  globalState?: Partial<<%= h.changeCase.pascal(documentType) %>GlobalState>,
-  localState?: Partial<<%= h.changeCase.pascal(documentType) %>LocalState>,
-): <%= h.changeCase.pascal(documentType) %>PHState {
+  globalState?: Partial<<%= globalStateName %>>,
+  localState?: Partial<<%= localStateName %>>,
+): <%= phStateName %> {
   return {
     ...createBaseState(baseState?.auth, baseState?.document),
     global: createGlobalState(globalState),
@@ -69,18 +69,18 @@ export function createState(
 }
 
 /**
- * Creates a <%= h.changeCase.pascal(documentType) %>Document with custom global and local state
+ * Creates a <%= phDocumentTypeName %> with custom global and local state
  * This properly handles the PHBaseState requirements while allowing
  * document-specific state to be set.
  */
-export function create<%= h.changeCase.pascal(documentType) %>Document(
+export function create<%= phDocumentTypeName %>(
   state?: Partial<{
     auth?: Partial<PHAuthState>;
     document?: Partial<PHDocumentState>;
-    global?: Partial<<%= h.changeCase.pascal(documentType) %>GlobalState>;
-    local?: Partial<<%= h.changeCase.pascal(documentType) %>LocalState>;
+    global?: Partial<<%= globalStateName %>>;
+    local?: Partial<<%= localStateName %>>;
   }>,
-): <%= h.changeCase.pascal(documentType) %>Document {
+): <%= phDocumentTypeName %> {
   const document = createDocument(
     state ? createState(
       createBaseState(state.auth, state.document),

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

@@ -1,5 +1,5 @@
 ---
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/reducer.ts"
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/reducer.ts"
 force: true
 ---
 // TODO: remove eslint-disable rules once refactor is done
@@ -7,14 +7,21 @@ force: true
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 import type { StateReducer } from "document-model";
 import { isDocumentAction, createReducer } from "document-model/core";
-import type { <%= h.changeCase.pascal(documentType) %>PHState } from './types.js';
-import { z } from './types.js';
+import type { <%= phStateName %> } from "<%= documentModelDir %>";
 
-<% modules.forEach(m => { _%>
-import { reducer as <%= h.changeCase.pascal(m.name) %>Reducer } from '../src/reducers/<%= h.changeCase.param(m.name) %>.js';
+<% modules.forEach(module => { _%>
+import { <%= camelCaseDocumentType %><%= h.changeCase.pascal(module.name) %>Operations } from "../src/reducers/<%= h.changeCase.param(module.name) %>.js";
 <%_ }); %>
 
-export const stateReducer: StateReducer<<%= h.changeCase.pascal(documentType) %>PHState> =
+<% const schemas = modules.flatMap(m =>
+     m.operations.map(o => `${h.changeCase.pascalCase(o.name)}InputSchema`)
+   );
+%>
+import {
+  <%= schemas.join(',\n  ') %>
+} from "./schema/zod.js";
+
+const stateReducer: StateReducer<<%= phStateName %>> =
     (state, action, dispatch) => {
         if (isDocumentAction(action)) {
             return state;
@@ -25,9 +32,9 @@ export const stateReducer: StateReducer<<%= h.changeCase.pascal(documentType) %>
     modules.map(m => m.operations.map(o => 
         '            case "' + h.changeCase.constant(o.name) + '":\n' + 
         '                ' + (o.schema !== null ? 
-            'z.' + h.changeCase.pascalCase(o.name) + 'InputSchema().parse(action.input);\n' : 
+            h.changeCase.pascalCase(o.name) + 'InputSchema().parse(action.input);\n' : 
             'if (Object.keys(action.input).length > 0) throw new Error("Expected empty input for action ' + h.changeCase.constant(o.name) + '");\n') +
-        '                ' + h.changeCase.pascal(m.name) + 'Reducer.' + h.changeCase.camel(o.name) + 'Operation((state as any)[action.scope], action as any, dispatch);\n' +
+        '                ' + camelCaseDocumentType + h.changeCase.pascal(m.name)  + 'Operations.' + h.changeCase.camel(o.name) + 'Operation((state as any)[action.scope], action as any, dispatch);\n' +
         '                break;\n'        
     ).join('\n')).join('\n')
 %>
@@ -36,4 +43,4 @@ export const stateReducer: StateReducer<<%= h.changeCase.pascal(documentType) %>
         }
     }
 
-export const reducer = createReducer<<%= h.changeCase.pascal(documentType) %>PHState>(stateReducer);
+export const reducer = createReducer<<%= phStateName %>>(stateReducer);

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/root-utils.esm.t

@@ -0,0 +1,11 @@
+---
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/utils.ts"
+force: true
+---
+import type { DocumentModelUtils } from "document-model";
+import type { <%= phStateName %> } from "./gen/types.js";
+import { utils as genUtils } from "./gen/utils.js";
+import * as customUtils from "./src/utils.js";
+
+/** Utils for the <%= pascalCaseDocumentType %> document model */
+export const utils = { ...genUtils, ...customUtils } satisfies DocumentModelUtils<<%= phStateName %>>;

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

@@ -0,0 +1,13 @@
+---
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/actions.ts"
+force: true
+---
+import { baseActions } from "document-model";
+import { <% modules.forEach(module => { _%>
+<%= h.changeCase.camel(module.name) %>Actions,
+<% }); _%>  } from "./gen/creators.js";
+
+/** Actions for the <%= pascalCaseDocumentType %> document model */
+export const actions = { ...baseActions, <% modules.forEach(module => { _%>
+   ...<%= h.changeCase.camel(module.name) %>Actions,
+<% }); _%> };