@powerhousedao/codegen 6.0.2-staging.2 → 6.0.2-staging.4

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

@@ -1,49 +0,0 @@
----
-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,23 +0,0 @@
----
-to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/index.ts"
-force: true
----
-export * from './actions.js';
-export * from './document-model.js';
-export * from './types.js';
-export * from './creators.js';
-export {
-  create<%= phDocumentTypeName %>,
-  createState,
-  defaultPHState,
-  defaultGlobalState,
-  defaultLocalState,
-} 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,127 +0,0 @@
-// @ts-check
-const { kebabCase, pascalCase, camelCase } = require("change-case");
-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,
-  );
-}
-
-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 kebabCaseDocumentType = kebabCase(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/${kebabCaseDocumentType}`;
-    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`;
-    return {
-      rootDir,
-      packageName,
-      useByIdHookName,
-      useSelectedHookName,
-      useInSelectedDriveHookName,
-      useInSelectedFolderHookName,
-      documentModel: documentModelToString(documentModel),
-      documentTypeVariableName,
-      documentTypeId,
-      documentType,
-      camelCaseDocumentType,
-      kebabCaseDocumentType,
-      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: kebabCase(m.name),
-      })),
-      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("{");
-}
-
-function handleEmptyState(state) {
-  return state === "" ? "{}" : state;
-}

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

@@ -1,22 +0,0 @@
----
-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 <%= pascalCaseDocumentType %> 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,93 +0,0 @@
----
-to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/ph-factories.ts"
-force: true
----
-/**
- * Factory methods for creating <%= phDocumentTypeName %> instances
- */
-import type {
-  PHAuthState,
-  PHDocumentState,
-  PHBaseState,
-} from "document-model";
-import {
-  createBaseState,
-  defaultBaseState,
-} from "document-model/core";
-import type {
-  <%= phDocumentTypeName %>,
-  <%= localStateName %>,
-  <%= globalStateName %>,
-  <%= phStateName %>,
-} from "./types.js";
-import { createDocument } from "./utils.js";
-
-export function defaultGlobalState(): <%= globalStateName %> {
-  return <%- initialGlobalState %>;
-}
-
-export function defaultLocalState(): <%= localStateName %> {
-  return <%- initialLocalState %>;
-}
-
-export function defaultPHState(): <%= phStateName %> {
-  return {
-    ...defaultBaseState(),
-    global: defaultGlobalState(),
-    local: defaultLocalState(),
-  };
-}
-
-export function createGlobalState(
-  state?: Partial<<%= globalStateName %>>,
-): <%= globalStateName %> {
-  return {
-    ...defaultGlobalState(),
-    ...(state || {}),
-  } as <%= globalStateName %>;
-}
-
-export function createLocalState(
-  state?: Partial<<%= localStateName %>>,
-): <%= localStateName %> {
-  return {
-    ...defaultLocalState(),
-    ...(state || {}),
-  } as <%= localStateName %>;
-}
-
-export function createState(
-  baseState?: Partial<PHBaseState>,
-  globalState?: Partial<<%= globalStateName %>>,
-  localState?: Partial<<%= localStateName %>>,
-): <%= phStateName %> {
-  return {
-    ...createBaseState(baseState?.auth, baseState?.document),
-    global: createGlobalState(globalState),
-    local: createLocalState(localState),
-  };
-}
-
-/**
- * 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<%= phDocumentTypeName %>(
-  state?: Partial<{
-    auth?: Partial<PHAuthState>;
-    document?: Partial<PHDocumentState>;
-    global?: Partial<<%= globalStateName %>>;
-    local?: Partial<<%= localStateName %>>;
-  }>,
-): <%= phDocumentTypeName %> {
-  const document = createDocument(
-    state ? createState(
-      createBaseState(state.auth, state.document),
-      state.global,
-      state.local,
-    ) : undefined
-  );
-
-  return document;
-}

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

@@ -1,46 +0,0 @@
----
-to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/reducer.ts"
-force: true
----
-// TODO: remove eslint-disable rules once refactor is done
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-import type { StateReducer } from "document-model";
-import { isDocumentAction, createReducer } from "document-model/core";
-import type { <%= phStateName %> } from "<%= documentModelDir %>";
-
-<% modules.forEach(module => { _%>
-import { <%= camelCaseDocumentType %><%= h.changeCase.pascal(module.name) %>Operations } from "../src/reducers/<%= h.changeCase.param(module.name) %>.js";
-<%_ }); %>
-
-<% 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;
-        }
-
-        switch (action.type) {
-<%-
-    modules.map(m => m.operations.map(o => 
-        '            case "' + h.changeCase.constant(o.name) + '":\n' + 
-        '                ' + (o.schema !== null ? 
-            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') +
-        '                ' + 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')
-%>
-            default:
-                return state;
-        }
-    }
-
-export const reducer = createReducer<<%= phStateName %>>(stateReducer);

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

@@ -1,11 +0,0 @@
----
-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

@@ -1,13 +0,0 @@
----
-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,
-<% }); _%> };

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

@@ -1,14 +0,0 @@
----
-to: "<%= rootDir %>/<%= paramCaseDocumentType %>/index.ts"
-force: true
----
-/**
- * This is a scaffold file meant for customization.
- * Delete the file and run the code generator again to have it reset
- */
-
-export * from "./gen/index.js";
-export * from "./src/index.js";
-export * from "./hooks.js";
-export { actions } from "./actions.js";
-export { utils } from "./utils.js";

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

@@ -1,6 +0,0 @@
----
-to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/schema/index.ts"
-force: true
----
-export * from "./types.js";
-export * from "./zod.js";

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

@@ -1,5 +0,0 @@
----
-to: "<%= rootDir %>/<%= paramCaseDocumentType %>/src/index.ts"
-force: true
----
-export * from "./utils.js";

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

@@ -1,31 +0,0 @@
----
-to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/types.ts"
-force: true
----
-import type { PHDocument, PHBaseState } from 'document-model';
-import type { <%= actionTypeName %> } from './actions.js';
-import type {
-  <%= stateName %> as <%= globalStateName %>,
-<% if(hasLocalSchema) { -%>
-  <%= localStateName %>,
-<%} -%>
-} from './schema/types.js';
-
-<% if(!hasLocalSchema) { -%>
-<%= 'type ' + localStateName %> = Record<PropertyKey, never>;
-<%} -%>
-type <%= phStateName %> = PHBaseState & {
-  global: <%= globalStateName %>;
-  local: <%= localStateName %>;
-};
-type <%= phDocumentTypeName %> = PHDocument<<%= phStateName %>>;
-
-export * from './schema/types.js';
-
-export type { 
-  <%= globalStateName %>, 
-  <%= localStateName %>,
-  <%= phStateName %>, 
-  <%= actionTypeName %>,
-  <%= phDocumentTypeName %>,
-};

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

@@ -1,77 +0,0 @@
----
-to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/utils.ts"
-force: true
----
-import type {
-    DocumentModelUtils,
-} from "document-model";
-import { 
-    baseCreateDocument,
-    baseSaveToFileHandle,
-    baseLoadFromInput,
-    defaultBaseState,
-    generateId,
- } from 'document-model/core';
-import type { 
-  <%= globalStateName %>,
-  <%= localStateName %>
-} from './types.js';
-import type { <%= phStateName %> } from './types.js';
-import { reducer } from './reducer.js';
-import { <%= documentTypeVariableName %> } from "./document-type.js";
-import {
-  <%= isPhDocumentOfTypeFunctionName %>,
-  <%= assertIsPhDocumentOfTypeFunctionName %>,
-  <%= isPhStateOfTypeFunctionName %>,
-  <%= assertIsPhStateOfTypeFunctionName %>,
-} from "./document-schema.js";
-
-export const initialGlobalState: <%= globalStateName %> = <%- initialGlobalState %>;
-export const initialLocalState: <%= localStateName %> = <%- initialLocalState %>;
-
-export const utils: DocumentModelUtils<<%= phStateName %>> = {
-    fileExtension: '<%- fileExtension %>',
-    createState(state) {
-        return { ...defaultBaseState(), global: { ...initialGlobalState, ...state?.global }, local: { ...initialLocalState, ...state?.local } };
-    },
-    createDocument(state) {
-        const document = baseCreateDocument(
-            utils.createState,
-            state
-        );
-
-        document.header.documentType = <%= documentTypeVariableName %>;
-
-        // for backwards compatibility, but this is NOT a valid signed document id
-        document.header.id = generateId();
-
-        return document;
-    },
-    saveToFileHandle(document, input) {
-        return baseSaveToFileHandle(document, input);
-    },
-    loadFromInput(input) {
-        return baseLoadFromInput(input, reducer);
-    },
-    isStateOfType(state) {
-        return <%= isPhStateOfTypeFunctionName %>(state);
-    },
-    assertIsStateOfType(state) {
-        return <%= assertIsPhStateOfTypeFunctionName %>(state);
-    },
-    isDocumentOfType(document) {
-        return <%= isPhDocumentOfTypeFunctionName %>(document);
-    },
-    assertIsDocumentOfType(document) {
-        return <%= assertIsPhDocumentOfTypeFunctionName %>(document);
-    },
-};
-
-export const createDocument = utils.createDocument;
-export const createState = utils.createState;
-export const saveToFileHandle = utils.saveToFileHandle;
-export const loadFromInput = utils.loadFromInput;
-export const isStateOfType = utils.isStateOfType;
-export const assertIsStateOfType = utils.assertIsStateOfType;
-export const isDocumentOfType = utils.isDocumentOfType;
-export const assertIsDocumentOfType = utils.assertIsDocumentOfType;

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

@@ -1,22 +0,0 @@
----
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/<%= module %>/actions.ts"
-force: true
----
-import { type Action<% if (actions.find(a => a.hasAttachment)) {%>, ActionWithAttachment<%}%> } from 'document-model';
-import type {
-<% actions.filter(a => a.hasInput).forEach(action => { _%>
-    <%= h.changeCase.pascal(action.name) %>Input,
-<% }); _%>
-} from '../types.js';
-
-<% actions.filter(a => a.hasInput).forEach(actionType => { _%>
-export <%= 'type ' + h.changeCase.pascal(actionType.name) %>Action = <%if(actionType.hasAttachment){ %>ActionWithAttachment<% } else { %>Action<% } %> & { type: '<%= h.changeCase.constantCase(actionType.name) %>'; input: <%= h.changeCase.pascal(actionType.name) %>Input };
-<% }); _%>
-<% actions.filter(a => !a.hasInput).forEach(actionType => { _%>
-export <%= 'type ' + h.changeCase.pascal(actionType.name) %>Action = Action & { type: '<%= h.changeCase.constantCase(actionType.name) %>'; input: {} };
-<% }); _%>
-
-export <%= 'type ' + h.changeCase.pascal(documentType) %><%= h.changeCase.pascal(module) %>Action = 
-<% actions.forEach(actionType => { _%>
-    | <%= h.changeCase.pascal(actionType.name) %>Action
-<% }); _%>;

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

@@ -1,37 +0,0 @@
----
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/<%= module %>/creators.ts"
-force: true
----
-import { createAction<% if (actions.find(a => a.hasAttachment)) {%>, AttachmentInput<%}%> } from 'document-model/core';
-import {
-<% actions.filter(a => a.hasInput).forEach(action => { _%>
-    <%= h.changeCase.pascal(action.name) %>InputSchema,
-<% }); _%>
-} from '../schema/zod.js';
-import type {
-<% actions.filter(a => a.hasInput).forEach(action => { _%>
-    <%= h.changeCase.pascal(action.name) %>Input,
-<% }); _%>
-} from '../types.js';
-import type {
-<% actions.forEach(action => { _%>
-    <%= h.changeCase.pascal(action.name) %>Action,
-<% }); _%>
-} from './actions.js';
-
-<% actions.filter(a => a.hasInput).forEach(action => { _%>
-export const <%= h.changeCase.camel(action.name) %> = (input<% if(action.isEmptyInput) { %>: <%= h.changeCase.pascal(action.name) %>Input = {}<% } else { %>: <%= h.changeCase.pascal(action.name) %>Input<% } %><%if(action.hasAttachment){ %>, attachments: AttachmentInput[] <% } %>) =>
-    createAction<<%= h.changeCase.pascal(action.name) %>Action>(
-        '<%= h.changeCase.constantCase(action.name) %>',
-        {...input},
-        <%if(action.hasAttachment){ %>attachments<% } else { %>undefined<% } %>,
-        <%= h.changeCase.pascalCase(action.name) %>InputSchema,
-        '<%= action.scope %>'
-    );
-
-<% }); _%>
-
-<% actions.filter(a => !a.hasInput).forEach(action => { _%>
-export const <%= h.changeCase.camel(action.name) %> = () =>
-    createAction<<%= h.changeCase.pascal(action.name) %>Action>('<%= h.changeCase.constantCase(action.name) %>');
-<% }); _%>

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

@@ -1,44 +0,0 @@
----
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/src/tests/<%= module %>.test.ts"
-unless_exists: true
----
-/**
- * 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 { generateMock } from '@powerhousedao/codegen';
-import {
-  reducer,
-  utils,
-  <%= isPhDocumentOfTypeFunctionName %>,
-  <% actions.forEach(action => { _%>
-    <%= h.changeCase.camel(action.name) %>,
-    <%= h.changeCase.pascal(action.name) %>InputSchema,
-<% }); _%> 
-} from "<%= documentModelDir %>";
-
-describe('<%= h.changeCase.pascal(module) %> Operations', () => {
-<% actions.forEach(action => { _%>
-    it('should handle <%= h.changeCase.camel(action.name) %> operation', () => {
-        const document = utils.createDocument();
-        const input = generateMock(
-            <%= h.changeCase.pascal(action.name) %>InputSchema(),
-        );
-
-        const updatedDocument = reducer(
-            document,
-            <%= h.changeCase.camel(action.name) %>(input),
-        );
-
-        expect(<%= isPhDocumentOfTypeFunctionName %>(updatedDocument)).toBe(true);
-        expect(updatedDocument.operations.<%= action.scope %>).toHaveLength(1);
-        expect(updatedDocument.operations.<%= action.scope %>[0].action.type).toBe(
-            '<%= h.changeCase.constant(action.name) %>',
-        );
-        expect(updatedDocument.operations.<%= action.scope %>[0].action.input).toStrictEqual(input);
-        expect(updatedDocument.operations.<%= action.scope %>[0].index).toEqual(0);
-    });
-<% }); _%> 
-});

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

@@ -1,36 +0,0 @@
----
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/<%= module %>/error.ts"
-force: true
----
-<% if (errors.length > 0) { _%>
-export type ErrorCode =
-<% errors.forEach((error, errorIndex) => { _%>
-    | "<%= h.changeCase.pascal(error.name) %>"<% if (errorIndex === errors.length - 1) { %>;<% } %>
-<% }); _%>
-
-export interface ReducerError {
-    errorCode: ErrorCode;
-}
-
-<% errors.forEach(error => { _%>
-export class <%= h.changeCase.pascal(error.name) %> extends Error implements ReducerError {
-    errorCode = "<%= h.changeCase.pascal(error.name) %>" as ErrorCode;
-    constructor(message = "<%= h.changeCase.pascal(error.name) %>") {
-        super(message);
-    }
-}
-
-<% }); _%>
-
-<% } _%>
-export const errors = {
-<% actions.forEach(action => { _%>
-<% if(action.errors?.length > 0){ -%>
-    <%= h.changeCase.pascal(action.name) %>: {
-    <% action.errors.forEach(error => { _%>
-        <%= h.changeCase.pascal(error.name) %>,
-    <% }); _%>
-    },
-<% } -%>
-<% }); _%>
-};