@powerhousedao/codegen 4.1.0-dev.9 → 4.1.0-dev.90

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

@@ -0,0 +1,10 @@
+// @ts-check
+const generateCustomSubgraph = {
+  params: ({ args }) => {
+    return {
+      rootDir: args.rootDir,
+      subgraph: args.subgraph,
+    };
+  },
+};
+module.exports = generateCustomSubgraph;

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

@@ -0,0 +1,17 @@
+---
+to: "<%= rootDir %>/<%= h.changeCase.param(subgraph) %>/resolvers.ts"
+unless_exists: true
+---
+import { type Subgraph } from "@powerhousedao/reactor-api";
+
+export const getResolvers = (subgraph: Subgraph): Record<string, unknown> => {
+  const reactor = subgraph.reactor;
+
+  return ({
+    Query: {
+      example: async (parent: unknown, args: { driveId: string }) => {
+        return "example";
+      },
+    },
+  });
+};

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

@@ -0,0 +1,16 @@
+---
+to: "<%= rootDir %>/<%= h.changeCase.param(subgraph) %>/schema.ts"
+unless_exists: true
+---
+import { gql } from "graphql-tag";
+import type { DocumentNode } from "graphql";
+
+export const schema: DocumentNode = gql`
+"""
+Subgraph definition
+"""
+type Query {
+    example(driveId: String!): String
+}
+
+`

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

@@ -2,6 +2,6 @@
 to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/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/index.esm.t

@@ -4,6 +4,12 @@ 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 * as actions from './creators.js';
+export {
+  create<%= h.changeCase.pascal(documentType) %>Document,
+  createState,
+  defaultPHState,
+  defaultGlobalState,
+  defaultLocalState,
+} from './ph-factories.js';

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

@@ -1,63 +1,78 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const change_case_1 = require("change-case");
+// @ts-check
+const { paramCase } = 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);
-}
-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];
+
     return {
-        initialGlobalState: handleEmptyState(global.initialValue),
-        initialLocalState: handleEmptyState(local.initialValue),
+      rootDir: args.rootDir,
+      documentModel: documentModelToString(documentModel),
+      documentTypeId: documentModel.id,
+      documentType: documentModel.name,
+      extension: documentModel.extension,
+      modules: latestSpec.modules.map((m) => ({
+        ...m,
+        name: paramCase(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("{");
+  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/ph-factories.esm.t

@@ -0,0 +1,93 @@
+---
+to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/ph-factories.ts"
+force: true
+---
+/**
+ * Factory methods for creating <%= h.changeCase.pascal(documentType) %>Document instances
+ */
+import type {
+  PHAuthState,
+  PHDocumentState,
+  PHBaseState,
+} from "document-model";
+import {
+  createBaseState,
+  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,
+} from "./types.js";
+import { createDocument } from "./utils.js";
+
+export function defaultGlobalState(): <%= h.changeCase.pascal(documentType) %>GlobalState {
+  return <%- initialGlobalState %>;
+}
+
+export function defaultLocalState(): <%= h.changeCase.pascal(documentType) %>LocalState {
+  return <%- initialLocalState %>;
+}
+
+export function defaultPHState(): <%= h.changeCase.pascal(documentType) %>PHState {
+  return {
+    ...defaultBaseState(),
+    global: defaultGlobalState(),
+    local: defaultLocalState(),
+  };
+}
+
+export function createGlobalState(
+  state?: Partial<<%= h.changeCase.pascal(documentType) %>GlobalState>,
+): <%= h.changeCase.pascal(documentType) %>GlobalState {
+  return {
+    ...defaultGlobalState(),
+    ...(state || {}),
+  } as <%= h.changeCase.pascal(documentType) %>GlobalState;
+}
+
+export function createLocalState(
+  state?: Partial<<%= h.changeCase.pascal(documentType) %>LocalState>,
+): <%= h.changeCase.pascal(documentType) %>LocalState {
+  return {
+    ...defaultLocalState(),
+    ...(state || {}),
+  } as <%= h.changeCase.pascal(documentType) %>LocalState;
+}
+
+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 {
+  return {
+    ...createBaseState(baseState?.auth, baseState?.document),
+    global: createGlobalState(globalState),
+    local: createLocalState(localState),
+  };
+}
+
+/**
+ * Creates a <%= h.changeCase.pascal(documentType) %>Document 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(
+  state?: Partial<{
+    auth?: Partial<PHAuthState>;
+    document?: Partial<PHDocumentState>;
+    global?: Partial<<%= h.changeCase.pascal(documentType) %>GlobalState>;
+    local?: Partial<<%= h.changeCase.pascal(documentType) %>LocalState>;
+  }>,
+): <%= h.changeCase.pascal(documentType) %>Document {
+  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

@@ -2,14 +2,19 @@
 to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/reducer.ts"
 force: true
 ---
-import { type StateReducer, isDocumentAction, createReducer } from "document-model";
-import { <%= 'type ' + h.changeCase.pascal(documentType) %>Document, z } from './types.js';
+// 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 { <%= h.changeCase.pascal(documentType) %>PHState } from './types.js';
+import { z } from './types.js';
 
 <% modules.forEach(m => { _%>
 import { reducer as <%= h.changeCase.pascal(m.name) %>Reducer } from '../src/reducers/<%= h.changeCase.param(m.name) %>.js';
 <%_ }); %>
 
-const stateReducer: StateReducer<<%= h.changeCase.pascal(documentType) %>Document> =
+export const stateReducer: StateReducer<<%= h.changeCase.pascal(documentType) %>PHState> =
     (state, action, dispatch) => {
         if (isDocumentAction(action)) {
             return state;
@@ -31,4 +36,4 @@ const stateReducer: StateReducer<<%= h.changeCase.pascal(documentType) %>Documen
         }
     }
 
-export const reducer = createReducer<<%= h.changeCase.pascal(documentType) %>Document>(stateReducer);
+export const reducer = createReducer<<%= h.changeCase.pascal(documentType) %>PHState>(stateReducer);

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

@@ -7,26 +7,25 @@ force: true
  * Delete the file and run the code generator again to have it reset
  */
 
-import { actions as BaseActions, type DocumentModelModule } from 'document-model';
+import { createState, type DocumentModelModule, baseActions } from 'document-model';
+import { defaultBaseState } from 'document-model/core';
 import { actions as <%= h.changeCase.pascal(documentType) %>Actions } from './gen/index.js';
 import { reducer } from './gen/reducer.js';
 import { documentModel } from './gen/document-model.js';
 import genUtils from './gen/utils.js';
 import * as customUtils from './src/utils.js';
-import {
-    <%= 'type ' + h.changeCase.pascal(documentType) %>Document,
-} from './gen/types.js';
+import type { <%= h.changeCase.pascal(documentType) %>PHState } from './gen/types.js';
 
 const utils = { ...genUtils, ...customUtils };
-const actions = { ...BaseActions, ...<%= h.changeCase.pascal(documentType) %>Actions };
+const actions = { ...baseActions, ...<%= h.changeCase.pascal(documentType) %>Actions };
 
 export const module: DocumentModelModule<
-    <%= h.changeCase.pascal(documentType) %>Document
+    <%= h.changeCase.pascal(documentType) %>PHState
 > = {
     reducer,
     actions,
     utils,
-    documentModel,
+    documentModel: createState(defaultBaseState(), documentModel),
 };
 
 export { reducer, actions, utils, documentModel };

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

@@ -2,18 +2,30 @@
 to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/types.ts"
 force: true
 ---
-import type { PHDocument, ExtendedState } from 'document-model';
-import type { <%= h.changeCase.pascal(documentType) %>State } from './schema/types.js';
+import type { PHDocument, PHBaseState } from 'document-model';
+import type { <%= h.changeCase.pascal(documentType) %>Action } from './actions.js';
+import type {
+  <%= h.changeCase.pascal(documentType) %>State as <%= h.changeCase.pascal(documentType) %>GlobalState,
 <% if(hasLocalSchema) { -%>
-import type { <%= h.changeCase.pascal(documentType) %>LocalState } from './schema/types.js';
+  <%= h.changeCase.pascal(documentType) %>LocalState,
 <%} -%>
-import type { <%= h.changeCase.pascal(documentType) %>Action } from './actions.js';
+} from './schema/types.js';
 
 export { z } from './schema/index.js';
-export type * from './schema/types.js';
+export * from './schema/types.js';
 <% if(!hasLocalSchema) { -%>
 <%= 'type ' + h.changeCase.pascal(documentType) %>LocalState = Record<PropertyKey, never>;
 <%} -%>
-export type Extended<%= h.changeCase.pascal(documentType) %>State = ExtendedState<<%= h.changeCase.pascal(documentType) %>State, <%= h.changeCase.pascal(documentType) %>LocalState>;
-export <%= 'type ' + h.changeCase.pascal(documentType) %>Document = PHDocument<<%= h.changeCase.pascal(documentType) %>State, <%= h.changeCase.pascal(documentType) %>LocalState>;
-export type { <%= h.changeCase.pascal(documentType) %>State, <%= h.changeCase.pascal(documentType) %>LocalState, <%= h.changeCase.pascal(documentType) %>Action };
+type <%= h.changeCase.pascal(documentType) %>PHState = PHBaseState & {
+  global: <%= h.changeCase.pascal(documentType) %>GlobalState;
+  local: <%= h.changeCase.pascal(documentType) %>LocalState;
+};
+type <%= h.changeCase.pascal(documentType) %>Document = PHDocument<<%= h.changeCase.pascal(documentType) %>PHState>;
+
+export type { 
+  <%= h.changeCase.pascal(documentType) %>GlobalState, 
+  <%= h.changeCase.pascal(documentType) %>LocalState,
+  <%= h.changeCase.pascal(documentType) %>PHState, 
+  <%= h.changeCase.pascal(documentType) %>Action,
+  <%= h.changeCase.pascal(documentType) %>Document,
+};

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

@@ -2,41 +2,35 @@
 to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/utils.ts"
 force: true
 ---
+import type {
+    DocumentModelUtils,
+} from "document-model";
 import { 
-    type DocumentModelUtils,
     baseCreateDocument,
-    baseCreateExtendedState,
-    baseSaveToFile,
     baseSaveToFileHandle,
-    baseLoadFromFile,
     baseLoadFromInput,
+    defaultBaseState,
     generateId,
- } from 'document-model';
-import { 
-  <%= 'type ' + h.changeCase.pascal(documentType) %>Document,
-  <%= 'type ' + h.changeCase.pascal(documentType) %>State,
-  <%= 'type ' + h.changeCase.pascal(documentType) %>LocalState
+ } from 'document-model/core';
+import type { 
+  <%= h.changeCase.pascal(documentType) %>GlobalState,
+  <%= h.changeCase.pascal(documentType) %>LocalState
 } from './types.js';
+import type { <%= h.changeCase.pascal(documentType) %>PHState } from './types.js';
 import { reducer } from './reducer.js';
 
-export const initialGlobalState: <%= h.changeCase.pascal(documentType) %>State = <%- initialGlobalState %>;
+export const initialGlobalState: <%= h.changeCase.pascal(documentType) %>GlobalState = <%- initialGlobalState %>;
 export const initialLocalState: <%= h.changeCase.pascal(documentType) %>LocalState = <%- initialLocalState %>;
 
-const utils: DocumentModelUtils<<%= h.changeCase.pascal(documentType) %>Document> = {
+const utils: DocumentModelUtils<<%= h.changeCase.pascal(documentType) %>PHState> = {
     fileExtension: '<%- fileExtension %>',
     createState(state) {
-        return { global: { ...initialGlobalState, ...state?.global }, local: { ...initialLocalState, ...state?.local } };
-    },
-    createExtendedState(extendedState) {
-        return baseCreateExtendedState(
-            { ...extendedState },
-            utils.createState
-        );
+        return { ...defaultBaseState(), global: { ...initialGlobalState, ...state?.global }, local: { ...initialLocalState, ...state?.local } };
     },
     createDocument(state) {
         const document = baseCreateDocument(
-            utils.createExtendedState(state),
-            utils.createState
+            utils.createState,
+            state
         );
 
         document.header.documentType = '<%- documentTypeId %>';
@@ -46,18 +40,17 @@ const utils: DocumentModelUtils<<%= h.changeCase.pascal(documentType) %>Document
 
         return document;
     },
-    saveToFile(document, path, name) {
-        return baseSaveToFile(document, path, '<%- fileExtension %>', name);
-    },
     saveToFileHandle(document, input) {
         return baseSaveToFileHandle(document, input);
     },
-    loadFromFile(path) {
-        return baseLoadFromFile(path, reducer);
-    },
     loadFromInput(input) {
         return baseLoadFromInput(input, reducer);
     },
 };
 
+export const createDocument = utils.createDocument;
+export const createState = utils.createState;
+export const saveToFileHandle = utils.saveToFileHandle;
+export const loadFromInput = utils.loadFromInput;
+
 export default utils;

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

@@ -2,7 +2,7 @@
 to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/<%= module %>/creators.ts"
 force: true
 ---
-import { createAction<% if (actions.find(a => a.hasAttachment)) {%>, AttachmentInput<%}%> } from 'document-model';
+import { createAction<% if (actions.find(a => a.hasAttachment)) {%>, AttachmentInput<%}%> } from 'document-model/core';
 import { z,
 <% actions.filter(a => a.hasInput).forEach(action => { _%>
     <%= 'type ' + h.changeCase.pascal(action.name) %>Input,

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

@@ -39,10 +39,10 @@ describe('<%= h.changeCase.pascal(module) %> Operations', () => {
         );
 
         expect(updatedDocument.operations.<%= action.scope %>).toHaveLength(1);
-        expect(updatedDocument.operations.<%= action.scope %>[0].type).toBe(
+        expect(updatedDocument.operations.<%= action.scope %>[0].action.type).toBe(
             '<%= h.changeCase.constant(action.name) %>',
         );
-        expect(updatedDocument.operations.<%= action.scope %>[0].input).toStrictEqual(input);
+        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

@@ -2,20 +2,17 @@
 to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/<%= module %>/error.ts"
 force: true
 ---
-<% if (actions.some(action => action.errors?.length > 0)) { _%>
+<% if (errors.length > 0) { _%>
 export type ErrorCode =
-<% actions.forEach((action, actionIndex) => { _%>
-<% action.errors.forEach((error, errorIndex) => { _%>
-    | '<%= h.changeCase.pascal(error.name) %>'<% if (actionIndex === actions.length - 1 && errorIndex === action.errors.length - 1) { %>;<% } %>
-<% }); _%>
+<% errors.forEach((error, errorIndex) => { _%>
+    | '<%= h.changeCase.pascal(error.name) %>'<% if (errorIndex === errors.length - 1) { %>;<% } %>
 <% }); _%>
 
 export interface ReducerError {
     errorCode: ErrorCode;
 }
 
-<% actions.forEach(action => { _%>
-<% action.errors.forEach(error => { _%>
+<% 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) %>') {
@@ -23,7 +20,6 @@ export class <%= h.changeCase.pascal(error.name) %> extends Error implements Red
     }
 }
 
-<% }); _%>
 <% }); _%>
 
 <% } _%>
@@ -32,9 +28,9 @@ export const errors = {
 <% if(action.errors?.length > 0){ -%>
     <%= h.changeCase.pascal(action.name) %>: {
     <% action.errors.forEach(error => { _%>
-    <%= h.changeCase.pascal(error.name) %>,
+        <%= h.changeCase.pascal(error.name) %>,
     <% }); _%>
-},
+    },
 <% } -%>
 <% }); _%>
 };