@powerhousedao/codegen 5.0.0-staging.9 → 5.0.1-staging.10

package/README.md

@@ -16,7 +16,6 @@ A powerful code generation toolkit for the Powerhouse ecosystem, designed to aut
 pnpm add @powerhousedao/codegen
 ```
 
-
 ## Templates
 
 The package supports custom templates for different output formats:

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./src/codegen/index.js";
 export * from "./src/create-lib/index.js";
+export * from "./src/ts-morph-generator/index.js";
 export * from "./src/utils/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,sBAAsB,CAAC"}

package/dist/index.js

@@ -1,4 +1,5 @@
 export * from "./src/codegen/index.js";
 export * from "./src/create-lib/index.js";
+export * from "./src/ts-morph-generator/index.js";
 export * from "./src/utils/index.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,sBAAsB,CAAC"}

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

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

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

@@ -1,6 +1,6 @@
 ---
 to: "<%= rootDir %>/<%= h.changeCase.param(subgraph) %>/resolvers.ts"
-force: true
+unless_exists: true
 ---
 import { type Subgraph } from "@powerhousedao/reactor-api";
 

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

@@ -1,6 +1,6 @@
 ---
 to: "<%= rootDir %>/<%= h.changeCase.param(subgraph) %>/schema.ts"
-force: true
+unless_exists: true
 ---
 import { gql } from "graphql-tag";
 import type { DocumentNode } from "graphql";

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,7 +1,7 @@
 ---
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/document-model.ts"
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/document-model.ts"
 force: true
 ---
-import type { DocumentModelState } from "document-model";
+import type { DocumentModelGlobalState } from "document-model";
 
-export const documentModel: DocumentModelState = <%- documentModel %>;
+export const documentModel: DocumentModelGlobalState = <%- documentModel %>;

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,17 +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 './object.js';
 export * from './types.js';
-export * as actions from './creators.js';
-export type { <%= h.changeCase.pascal(documentType) %>PHState } from './ph-factories.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,63 +1,137 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const change_case_1 = require("change-case");
+// @ts-check
+const { paramCase, pascalCase, camelCase } = require("change-case");
+const { getModuleExports } = require("../utils.js");
 function documentModelToString(documentModel) {
-    return JSON.stringify({
-        ...documentModel,
-        specifications: documentModel.specifications.map((s) => ({
-            ...s,
-            state: Object.keys(s.state).reduce((values, scope) => {
-                const state = s.state[scope];
-                return {
-                    ...values,
-                    [scope]: {
-                        ...state,
-                        // initial value has to be stringified twice
-                        // as it is expected to be a string
-                        initialValue: JSON.stringify(state.initialValue),
-                    },
-                };
-            }, {}),
-        })),
-    }, null, 2);
-}
-exports.default = {
-    params: ({ args, }) => {
-        const documentModel = JSON.parse(args.documentModel);
-        const latestSpec = documentModel.specifications[documentModel.specifications.length - 1];
-        return {
-            rootDir: args.rootDir,
-            documentModel: documentModelToString(documentModel),
-            documentTypeId: documentModel.id,
-            documentType: documentModel.name,
-            extension: documentModel.extension,
-            modules: latestSpec.modules.map((m) => ({
-                ...m,
-                name: (0, change_case_1.paramCase)(m.name),
-            })),
-            fileExtension: documentModel.extension,
-            hasLocalSchema: latestSpec.state.local.schema !== "",
-            ...getInitialStates(latestSpec.state),
-        };
+  return JSON.stringify(
+    {
+      ...documentModel,
+      specifications: documentModel.specifications.map((s) => ({
+        ...s,
+        state: Object.keys(s.state).reduce((values, scope) => {
+          const state = s.state[scope];
+          return {
+            ...values,
+            [scope]: {
+              ...state,
+              // initial value has to be stringified twice
+              // as it is expected to be a string
+              initialValue: JSON.stringify(state.initialValue),
+            },
+          };
+        }, {}),
+      })),
     },
-};
-function getInitialStates(scopeState) {
-    const { global, local } = scopeState;
-    const scopes = { global, local };
-    Object.entries(scopes).forEach(([scope, state]) => {
-        if (!isEmptyStateSchema(state.schema) && state.initialValue === "") {
-            throw new Error(`${scope.charAt(0).toLocaleUpperCase() + scope.slice(1)} scope has a defined schema but is missing an initial value.`);
-        }
-    });
+    null,
+    2,
+  );
+}
+
+module.exports = {
+  params: ({ args }) => {
+    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 {
-        initialGlobalState: handleEmptyState(global.initialValue),
-        initialLocalState: handleEmptyState(local.initialValue),
+      rootDir,
+      packageName,
+      useByIdHookName,
+      useSelectedHookName,
+      useInSelectedDriveHookName,
+      useInSelectedFolderHookName,
+      documentModel: documentModelToString(documentModel),
+      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),
+      })),
+      moduleExports,
+      fileExtension: documentModel.extension || "",
+      hasLocalSchema: latestSpec.state.local.schema !== "",
+      ...getInitialStates(latestSpec.state),
     };
+  },
+};
+
+function getInitialStates(scopeState) {
+  const { global, local } = scopeState;
+  const scopes = { global, local };
+
+  Object.entries(scopes).forEach(([scope, state]) => {
+    if (!isEmptyStateSchema(state.schema) && state.initialValue === "") {
+      throw new Error(
+        `${
+          scope.charAt(0).toLocaleUpperCase() + scope.slice(1)
+        } scope has a defined schema but is missing an initial value.`,
+      );
+    }
+  });
+
+  return {
+    initialGlobalState: handleEmptyState(global.initialValue),
+    initialLocalState: handleEmptyState(local.initialValue),
+  };
 }
+
 function isEmptyStateSchema(schema) {
-    return schema === "" || !schema.includes("{");
+  return schema === "" || !schema.includes("{");
 }
+
 function handleEmptyState(state) {
-    return state === "" ? "{}" : state;
+  return state === "" ? "{}" : state;
 }
-//# sourceMappingURL=index.js.map

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),
+};