@powerhousedao/codegen 0.0.4 → 0.0.5

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#! /usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,40 @@
+#! /usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./codegen/index");
+const utils_1 = require("./utils");
+async function parseCommand(argv) {
+    const args = (0, utils_1.parseArgs)(argv, {
+        '--editor': String,
+        '-e': '--editor',
+        '--document-types': String,
+    });
+    const editorName = args['--editor'];
+    return {
+        editor: !!editorName,
+        editorName,
+        documentTypes: args['--document-types'],
+        arg: args._,
+    };
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    const baseConfig = (0, utils_1.getConfig)();
+    const argsConfig = (0, utils_1.parseConfig)(argv);
+    const config = { ...baseConfig, ...argsConfig };
+    if (config.interactive) {
+        const result = await (0, utils_1.promptDirectories)(config);
+        Object.assign(config, result);
+    }
+    const command = await parseCommand(argv);
+    if (command.editor) {
+        await (0, index_1.generateEditor)(command.editorName, command.documentTypes?.split(/[|,;]/g) ?? [], config);
+    }
+    else if (command.arg.length === 2) {
+        await (0, index_1.generateFromFile)(command.arg[1], config);
+    }
+    else {
+        await (0, index_1.generate)(config);
+    }
+}
+main();

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,25 @@
+---
+to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/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
+*/
+
+import utils, { initialGlobalState, initialLocalState } from '../../gen/utils';
+
+describe('<%= h.changeCase.title(documentType) %> Document Model', () => {
+    it('should create a new <%= h.changeCase.title(documentType) %> document', () => {
+        const document = utils.createDocument();
+
+        expect(document).toBeDefined();
+        expect(document.documentType).toBe('<%- documentTypeId %>');
+    });
+
+    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);
+    });
+});

package/dist/codegen/.hygen/templates/powerhouse/generate-document-model/index.d.ts

@@ -0,0 +1,27 @@
+export type Args = {
+    documentModel: string;
+    rootDir: string;
+};
+declare const _default: {
+    params: ({ args }: {
+        args: Args;
+    }) => {
+        initialGlobalState: string;
+        initialLocalState: string;
+        rootDir: string;
+        documentModel: string;
+        documentTypeId: string;
+        documentType: string;
+        extension: string;
+        modules: {
+            name: string;
+            __typename?: "Module" | undefined;
+            description: import("document-model/document-model").Maybe<string>;
+            id: string;
+            operations: import("document-model/document-model").Operation[];
+        }[];
+        fileExtension: string;
+        hasLocalSchema: boolean;
+    };
+};
+export default _default;

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

@@ -0,0 +1,9 @@
+---
+to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/index.ts"
+force: true
+---
+export * from './actions';
+export * from './document-model';
+export * from './object';
+export * from './types';
+export * as actions from './creators';

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const change_case_1 = 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, 4);
+}
+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),
+        };
+    },
+};
+function getInitialStates(scopeState) {
+    const { global, local } = scopeState;
+    const scopes = { global, local };
+    Object.entries(scopes).forEach(([scope, state]) => {
+        if (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 handleEmptyState(state) {
+    return state === '' ? '{}' : state;
+}

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

@@ -0,0 +1,9 @@
+---
+to: "<%= rootDir %>/index.ts"
+unless_exists: true
+---
+/**
+* This is a scaffold file meant for customization.
+* Delete the file and run the code generator again to have it reset
+*/
+

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

@@ -0,0 +1,7 @@
+---
+inject: true
+append: true
+to: "<%= rootDir %>/index.ts"
+skip_if: "<%= h.changeCase.pascal(documentType) %>"
+---
+export { module as <%= h.changeCase.pascal(documentType) %> } from './<%= h.changeCase.param(documentType)  %>';

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

@@ -0,0 +1,49 @@
+---
+to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/object.ts"
+force: true
+---
+import { BaseDocument, ExtendedState, PartialState, applyMixins, SignalDispatch } from 'document-model/document';
+import { <%= h.changeCase.pascal(documentType) %>State, <%= h.changeCase.pascal(documentType) %>LocalState } from './types';
+import { <%= h.changeCase.pascal(documentType) %>Action } from './actions';
+import { reducer } from './reducer';
+import utils from './utils';
+<% modules.forEach(module => { _%>
+import <%= h.changeCase.pascal(documentType) %>_<%= h.changeCase.pascal(module.name) %> from './<%= module.name %>/object';
+<% }); _%>
+
+<% modules.forEach(module => { _%>
+export * from './<%= module.name %>/object';
+<% }); _%>
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+interface <%= h.changeCase.pascal(documentType) %> extends 
+<%= modules.map(m => '    ' + h.changeCase.pascal(documentType) + '_' + h.changeCase.pascal(m.name)).join(',\n') %> {}
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+class <%= h.changeCase.pascal(documentType) %> extends BaseDocument<<%= h.changeCase.pascal(documentType) %>State, <%= h.changeCase.pascal(documentType) %>Action, <%= h.changeCase.pascal(documentType) %>LocalState> {
+    static fileExtension = '<%= extension %>';
+
+    constructor(initialState?: Partial<ExtendedState<PartialState<<%= h.changeCase.pascal(documentType) %>State>, PartialState<<%= h.changeCase.pascal(documentType) %>LocalState>>>, dispatch?: SignalDispatch) {
+        super(reducer, utils.createDocument(initialState), dispatch);
+    }
+
+    public saveToFile(path: string, name?: string) {
+        return super.saveToFile(path, <%= h.changeCase.pascal(documentType) %>.fileExtension, name);
+    }
+
+    public loadFromFile(path: string) {
+        return super.loadFromFile(path);
+    }
+
+    static async fromFile(path: string) {
+        const document = new this();
+        await document.loadFromFile(path);
+        return document;
+    }
+}
+
+applyMixins(<%= h.changeCase.pascal(documentType) %>, [
+<%= modules.map(m => '    ' + h.changeCase.pascal(documentType) + '_' + h.changeCase.pascal(m.name)).join(',\n') %>
+]);
+
+export { <%= h.changeCase.pascal(documentType) %> };

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

@@ -0,0 +1,35 @@
+---
+to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/reducer.ts"
+force: true
+---
+import { ImmutableStateReducer, utils } from "document-model/document";
+import { <%= h.changeCase.pascal(documentType) %>State, <%= h.changeCase.pascal(documentType) %>LocalState, z } from './schema';
+import { <%= h.changeCase.pascal(documentType) %>Action } from './actions';
+
+<% modules.forEach(m => { _%>
+import { reducer as <%= h.changeCase.pascal(m.name) %>Reducer } from '../src/reducers/<%= h.changeCase.param(m.name) %>';
+<%_ }); %>
+
+const stateReducer: ImmutableStateReducer<<%= h.changeCase.pascal(documentType) %>State, <%= h.changeCase.pascal(documentType) %>Action, <%= h.changeCase.pascal(documentType) %>LocalState> =
+    (state, action, dispatch) => {
+        if (utils.isBaseAction(action)) {
+            return state;
+        }
+
+        switch (action.type) {
+<%-
+    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' : 
+            '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[action.scope], action, dispatch);\n' +
+        '                break;\n'        
+    ).join('\n')).join('\n')
+%>
+            default:
+                return state;
+        }
+    }
+
+export const reducer = utils.createReducer<<%= h.changeCase.pascal(documentType) %>State, <%= h.changeCase.pascal(documentType) %>Action, <%= h.changeCase.pascal(documentType) %>LocalState>(stateReducer);

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

@@ -0,0 +1,44 @@
+---
+to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/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
+*/
+
+import { actions as BaseActions, DocumentModel } from 'document-model/document';
+import { actions as <%= h.changeCase.pascal(documentType) %>Actions, <%= h.changeCase.pascal(documentType) %> } from './gen';
+import { reducer } from './gen/reducer';
+import { documentModel } from './gen/document-model';
+import genUtils from './gen/utils';
+import * as customUtils from './src/utils';
+import { <%= h.changeCase.pascal(documentType) %>State, <%= h.changeCase.pascal(documentType) %>Action } from './gen/types';
+
+const Document = <%= h.changeCase.pascal(documentType) %>;
+const utils = { ...genUtils, ...customUtils };
+const actions = { ...BaseActions, ...<%= h.changeCase.pascal(documentType) %>Actions };
+
+export const module: DocumentModel<
+    <%= h.changeCase.pascal(documentType) %>State,
+    <%= h.changeCase.pascal(documentType) %>Action,
+    <%= h.changeCase.pascal(documentType) %>
+> = {
+    Document,
+    reducer,
+    actions,
+    utils,
+    documentModel
+};
+
+export {
+    <%= h.changeCase.pascal(documentType) %>,
+    Document,
+    reducer,
+    actions,
+    utils,
+    documentModel
+}
+
+export * from './gen/types';
+export * from './src/utils';

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

@@ -0,0 +1,6 @@
+---
+to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/schema/index.ts"
+force: true
+---
+export * from "./types";
+export * as z from "./zod";

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

@@ -0,0 +1,19 @@
+---
+to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/types.ts"
+force: true
+---
+import type { Document, ExtendedState } from 'document-model/document';
+import type { <%= h.changeCase.pascal(documentType) %>State } from './schema/types';
+<% if(hasLocalSchema) { -%>
+import type { <%= h.changeCase.pascal(documentType) %>LocalState } from './schema/types';
+<%} -%>
+import type { <%= h.changeCase.pascal(documentType) %>Action } from './actions';
+
+export { z } from './schema';
+export type * from './schema/types';
+<% 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 = Document<<%= h.changeCase.pascal(documentType) %>State, <%= h.changeCase.pascal(documentType) %>Action, <%= h.changeCase.pascal(documentType) %>LocalState>;
+export { <%= h.changeCase.pascal(documentType) %>State, <%= h.changeCase.pascal(documentType) %>LocalState, <%= h.changeCase.pascal(documentType) %>Action };

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

@@ -0,0 +1,43 @@
+---
+to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/utils.ts"
+force: true
+---
+import { DocumentModelUtils, utils as base } from 'document-model/document';
+import { <%= h.changeCase.pascal(documentType) %>Action, <%= h.changeCase.pascal(documentType) %>State, <%= h.changeCase.pascal(documentType) %>LocalState } from './types';
+import { reducer } from './reducer';
+
+export const initialGlobalState: <%= h.changeCase.pascal(documentType) %>State = <%- initialGlobalState %>;
+export const initialLocalState: <%= h.changeCase.pascal(documentType) %>LocalState = <%- initialLocalState %>;
+
+const utils: DocumentModelUtils<<%= h.changeCase.pascal(documentType) %>State, <%= h.changeCase.pascal(documentType) %>Action, <%= h.changeCase.pascal(documentType) %>LocalState> = {
+    fileExtension: '<%- fileExtension %>',
+    createState(state) {
+        return { global: { ...initialGlobalState, ...state?.global }, local: { ...initialLocalState, ...state?.local } };
+    },
+    createExtendedState(extendedState) {
+        return base.createExtendedState(
+            { ...extendedState, documentType: '<%- documentTypeId %>' },
+            utils.createState
+        );
+    },
+    createDocument(state) {
+        return base.createDocument(
+            utils.createExtendedState(state),
+            utils.createState
+        );
+    },
+    saveToFile(document, path, name) {
+        return base.saveToFile(document, path, '<%- fileExtension %>', name);
+    },
+    saveToFileHandle(document, input) {
+        return base.saveToFileHandle(document, input);
+    },
+    loadFromFile(path) {
+        return base.loadFromFile(path, reducer);
+    },
+    loadFromInput(input) {
+        return base.loadFromInput(input, reducer);
+    },
+};
+
+export default utils;

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

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

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

@@ -0,0 +1,34 @@
+---
+to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/<%= module %>/creators.ts"
+force: true
+---
+import { utils<% if (actions.find(a => a.hasAttachment)) {%>, AttachmentInput<%}%> } from 'document-model/document';
+import { z,
+<% actions.filter(a => a.hasInput).forEach(action => { _%>
+    <%= h.changeCase.pascal(action.name) %>Input,
+<% }); _%>
+} from '../types';
+import {
+<% actions.forEach(action => { _%>
+    <%= h.changeCase.pascal(action.name) %>Action,
+<% }); _%>
+} from './actions';
+
+const { createAction } = utils;
+
+<% actions.filter(a => a.hasInput).forEach(action => { _%>
+export const <%= h.changeCase.camel(action.name) %> = (input: <%= 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<% } %>,
+        z.<%= 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/codegen/.hygen/templates/powerhouse/generate-document-model-module/customReducers.esm.t

@@ -0,0 +1,20 @@
+---
+to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/src/reducers/<%= module %>.ts"
+unless_exists: true
+---
+/**
+* This is a scaffold file meant for customization: 
+* - modify it by implementing the reducer functions
+* - delete the file and run the code generator again to have it reset
+*/
+
+import { <%= h.changeCase.pascal(documentType) %><%= h.changeCase.pascal(module) %>Operations } from '../../gen/<%= module %>/operations';
+
+export const reducer: <%= h.changeCase.pascal(documentType) %><%= h.changeCase.pascal(module) %>Operations = {
+<% actions.forEach(action => { _%>
+    <%= h.changeCase.camel(action.name) %>Operation(state, action, dispatch) {
+        // TODO: Implement "<%= h.changeCase.camel(action.name) %>Operation" reducer
+        throw new Error('Reducer "<%= h.changeCase.camel(action.name) %>Operation" not yet implemented');
+    },
+<% }); _%>
+}

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

@@ -0,0 +1,38 @@
+---
+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 { generateMock } from '@acaldas/powerhouse';
+
+import utils from '../../gen/utils';
+import { z } from '../../gen/schema'; 
+import { reducer } from '../../gen/reducer';
+import * as creators from '../../gen/<%= module %>/creators';
+import { <%= h.changeCase.pascal(documentType) %>Document } from '../../gen/types';
+
+
+describe('<%= h.changeCase.pascal(module) %> Operations', () => {
+    let document: <%= h.changeCase.pascal(documentType) %>Document;
+
+    beforeEach(() => {
+        document = utils.createDocument();
+    });
+
+<% actions.forEach(action => { _%>
+    it('should handle <%= h.changeCase.camel(action.name) %> operation', () => {
+        const input = generateMock(z.<%= h.changeCase.pascal(action.name) %>InputSchema());
+        const updatedDocument = reducer(document, creators.<%= h.changeCase.camel(action.name) %>(input));
+
+        expect(updatedDocument.operations.<%= action.scope %>).toHaveLength(1);
+        expect(updatedDocument.operations.<%= action.scope %>[0].type).toBe('<%= h.changeCase.constant(action.name) %>');
+        expect(updatedDocument.operations.<%= action.scope %>[0].input).toStrictEqual(input);
+        expect(updatedDocument.operations.<%= action.scope %>[0].index).toEqual(0);
+    });
+
+<% }); _%> 
+});

package/dist/codegen/.hygen/templates/powerhouse/generate-document-model-module/index.d.ts

@@ -0,0 +1,21 @@
+import { Args } from '../generate-document-model';
+type ModuleArgs = Args & {
+    module: string;
+};
+declare const _default: {
+    params: ({ args }: {
+        args: ModuleArgs;
+    }) => {
+        rootDir: string;
+        documentType: string;
+        module: string;
+        actions: {
+            name: import("document-model/document-model").Maybe<string>;
+            hasInput: boolean;
+            hasAttachment: boolean | undefined;
+            scope: import("document-model/document").OperationScope;
+            state: string;
+        }[];
+    };
+};
+export default _default;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const change_case_1 = require("change-case");
+exports.default = {
+    params: ({ args }) => {
+        const documentModel = JSON.parse(args.documentModel);
+        const latestSpec = documentModel.specifications[documentModel.specifications.length - 1];
+        const filteredModules = latestSpec.modules.filter(m => m.name === args.module);
+        return {
+            rootDir: args.rootDir,
+            documentType: documentModel.name,
+            module: (0, change_case_1.paramCase)(args.module),
+            actions: filteredModules.length > 0
+                ? filteredModules[0].operations.map(a => ({
+                    name: a.name,
+                    hasInput: a.schema !== null,
+                    hasAttachment: a.schema?.includes(': Attachment'),
+                    scope: a.scope || 'global',
+                    state: a.scope === 'global' ? '' : a.scope, // the state this action affects
+                }))
+                : [],
+        };
+    },
+};

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

@@ -0,0 +1,37 @@
+---
+to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/<%= module %>/object.ts"
+force: true
+---
+import { BaseDocument<% if (actions.find(a => a.hasAttachment)) {%>, AttachmentInput<%}%> } from 'document-model/document';
+import {
+<% actions.filter(action => action.hasInput).forEach(action => { _%>
+    <%= h.changeCase.pascal(action.name) %>Input,
+<% }); _%>
+    <%= h.changeCase.pascal(documentType) %>State,
+    <%= h.changeCase.pascal(documentType) %>LocalState
+} from '../types';
+import {
+<% actions.forEach(action => { _%>
+    <%= h.changeCase.camel(action.name) %>,
+<% }); _%>
+} from './creators';
+import { <%= h.changeCase.pascal(documentType) %>Action } from '../actions';
+
+export default class <%= h.changeCase.pascal(documentType) %>_<%= h.changeCase.pascal(module) %> extends BaseDocument<
+    <%= h.changeCase.pascal(documentType) %>State,
+    <%= h.changeCase.pascal(documentType) %>Action,
+    <%= h.changeCase.pascal(documentType) %>LocalState
+> {
+<% actions.filter(action => action.hasInput).forEach(action => { _%>
+    public <%= h.changeCase.camel(action.name) %>(input: <%= h.changeCase.pascal(action.name) %>Input<%if(action.hasAttachment){ %>, attachments: AttachmentInput[] <% } %>) {
+        return this.dispatch(<%= h.changeCase.camel(action.name) %>(input<%if(action.hasAttachment){ %>, attachments<% } %>));
+    }
+    
+<% }); _%>
+<% actions.filter(action => !action.hasInput).forEach(action => { _%>
+    public <%= h.changeCase.camel(action.name) %>() {
+        return this.dispatch(<%= h.changeCase.camel(action.name) %>());
+    }
+    
+<% }); _%>
+}