@powerhousedao/codegen 6.0.0-dev.11 → 6.0.0-dev.110

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

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

@@ -1,71 +0,0 @@
-// @ts-check
-const { paramCase, pascalCase } = require("change-case");
-
-module.exports = {
-  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,
-    );
-
-    const actions =
-      filteredModules.length > 0
-        ? filteredModules[0].operations.map((a) => ({
-            name: a.name,
-            hasInput: a.schema !== null,
-            isEmptyInput:
-              a.schema?.includes("_empty") &&
-              !a.schema.replace(/_empty:\s*Boolean/, "").match(/\w+:\s*\w+/),
-            hasAttachment: a.schema?.includes(": Attachment"),
-            scope: a.scope || "global",
-            state: a.scope === "global" ? "" : a.scope, // the state this action affects
-            errors: a.errors,
-          }))
-        : [];
-
-    const errors = actions.reduce((acc, action) => {
-      action.errors.forEach((error) => {
-        // Fallback: If error code is empty, generate it from the error name in PascalCase
-        const errorCode = error.code || pascalCase(error.name || "");
-        const normalizedError = { ...error, code: errorCode };
-
-        const existingError = acc.find((e) => e.code === errorCode);
-        if (!existingError) {
-          acc.push(normalizedError);
-        } else if (
-          JSON.stringify(existingError) !== JSON.stringify(normalizedError)
-        ) {
-          console.warn(
-            `Warning: Duplicate error code "${errorCode}" with different fields found`,
-          );
-        }
-      });
-      return acc;
-    }, []);
-
-    const documentType = documentModel.name;
-    const pascalCaseDocumentType = pascalCase(documentType);
-    const phDocumentTypeName = `${pascalCaseDocumentType}Document`;
-    const isPhDocumentOfTypeFunctionName = `is${phDocumentTypeName}`;
-    const assertIsPhDocumentOfTypeFunctionName = `assertIs${phDocumentTypeName}`;
-    const paramCaseDocumentType = paramCase(documentType);
-    const packageName = args.packageName;
-    const documentModelDir = `${packageName}/document-models/${paramCaseDocumentType}`;
-    return {
-      rootDir: args.rootDir,
-      documentType: documentModel.name,
-      module: paramCase(args.module),
-      actions,
-      errors,
-      pascalCaseDocumentType,
-      paramCaseDocumentType,
-      packageName,
-      documentModelDir,
-      phDocumentTypeName,
-      isPhDocumentOfTypeFunctionName,
-      assertIsPhDocumentOfTypeFunctionName,
-    };
-  },
-};

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

@@ -1,17 +0,0 @@
----
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/<%= module %>/operations.ts"
-force: true
----
-import { type SignalDispatch } from 'document-model';
-import {
-<% actions.forEach(action => { _%>
-    <%= 'type ' + h.changeCase.pascal(action.name) %>Action,
-<% }); _%>
-} from './actions.js';
-import { <%= actions.map(action => 'type ' + h.changeCase.pascal(h.changeCase.pascal(documentType + '_' + action.state + '_State'))).filter((value, index, self) => self.indexOf(value) === index).join(', ') %> } from '../types.js';
-
-export interface <%= h.changeCase.pascal(documentType) %><%= h.changeCase.pascal(module) %>Operations {
-<% actions.forEach(action => { _%>
-    <%= h.changeCase.camel(action.name) %>Operation: (state: <%= h.changeCase.pascal(documentType + '_' + action.state + '_State') %>, action: <%= h.changeCase.pascal(action.name) %>Action, dispatch?: SignalDispatch) => void,
-<% }); _%>
-}

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

@@ -1,118 +0,0 @@
-// @ts-check
-const { paramCase, pascalCase, camelCase } = require("change-case");
-
-/**
- * Extract type names from a GraphQL schema.
- * @param {string} schema - GraphQL schema string
- * @returns {string[]} Array of type names
- */
-function extractTypeNames(schema) {
-  const found = schema.match(/(type|enum|union|interface|input)\s+(\w+)\s/g);
-  if (!found) return [];
-  return found.map((f) =>
-    f
-      .replaceAll("type ", "")
-      .replaceAll("enum ", "")
-      .replaceAll("union ", "")
-      .replaceAll("interface ", "")
-      .replaceAll("input ", "")
-      .trim()
-  );
-}
-
-/**
- * Apply type prefixes to GraphQL schema to namespace types and avoid collisions.
- * Inlined from @powerhousedao/common/utils to avoid ES module import issues.
- * @param {string} schema - GraphQL schema string
- * @param {string} prefix - Prefix to apply to type names
- * @param {string[]} externalTypeNames - Type names from other schemas to also prefix
- * @returns {string} Schema with prefixed types
- */
-function applyGraphQLTypePrefixes(schema, prefix, externalTypeNames = []) {
-  if (!schema || !schema.trim()) {
-    return schema;
-  }
-
-  let processedSchema = schema;
-
-  // Find types defined in this schema
-  const localTypeNames = extractTypeNames(schema);
-
-  // Combine with external type names (remove duplicates)
-  const allTypeNames = [...new Set([...localTypeNames, ...externalTypeNames])];
-
-  if (allTypeNames.length === 0) {
-    return schema;
-  }
-
-  allTypeNames.forEach((typeName) => {
-    const typeRegex = new RegExp(
-      // Match type references in various GraphQL contexts
-      `(?<![_A-Za-z0-9])(${typeName})(?![_A-Za-z0-9])|` +
-        `\\[(${typeName})\\]|` +
-        `\\[(${typeName})!\\]|` +
-        `\\[(${typeName})\\]!|` +
-        `\\[(${typeName})!\\]!`,
-      "g",
-    );
-
-    processedSchema = processedSchema.replace(
-      typeRegex,
-      (match, p1, p2, p3, p4, p5) => {
-        if (match.startsWith("[")) {
-          return match.replace(
-            p2 || p3 || p4 || p5,
-            `${prefix}_${p2 || p3 || p4 || p5}`,
-          );
-        }
-        // Basic type reference
-        return `${prefix}_${p1}`;
-      },
-    );
-  });
-
-  return processedSchema;
-}
-
-module.exports = {
-  params: ({ args }) => {
-    const documentModel = JSON.parse(args.documentModel);
-    const latestSpec =
-      documentModel.specifications[documentModel.specifications.length - 1];
-    const documentType = documentModel.name;
-    const pascalCaseDocumentType = pascalCase(documentType);
-    const camelCaseDocumentType = camelCase(documentType);
-    const phDocumentTypeName = `${pascalCaseDocumentType}Document`;
-    const documentTypeVariableName = `${camelCaseDocumentType}DocumentType`;
-    const packageName = args.packageName;
-    const paramCaseDocumentType = paramCase(documentType);
-    const documentModelDir = `${packageName}/document-models/${paramCaseDocumentType}`;
-
-    const stateSchema = latestSpec.state.global.schema;
-    const stateTypeNames = extractTypeNames(stateSchema);
-
-    return {
-      phDocumentTypeName,
-      documentTypeVariableName,
-      pascalCaseDocumentType,
-      camelCaseDocumentType,
-      documentModelDir,
-      rootDir: args.rootDir,
-      subgraph: args.subgraph,
-      documentTypeId: documentModel.id,
-      documentType: documentModel.name,
-      schema: applyGraphQLTypePrefixes(
-        stateSchema,
-        pascalCaseDocumentType
-      ),
-      modules: latestSpec.modules.map((m) => ({
-        ...m,
-        name: paramCase(m.name),
-        operations: m.operations.map((op) => ({
-          ...op,
-          schema: applyGraphQLTypePrefixes(op.schema, pascalCaseDocumentType, stateTypeNames),
-        })),
-      })),
-    };
-  },
-};