@powerhousedao/reactor-api 6.0.0-dev.153 → 6.0.0-dev.154

package/dist/src/utils/create-schema.js

@@ -1,728 +0,0 @@
-import { buildSubgraphSchema } from "@apollo/subgraph";
-import { typeDefs as scalarsTypeDefs } from "@powerhousedao/document-engineering/graphql";
-import { camelCase, pascalCase } from "change-case";
-import { childLogger } from "document-model";
-import { Kind, parse, print } from "graphql";
-import { gql } from "graphql-tag";
-import { GraphQLJSONObject } from "graphql-type-json";
-const logger = childLogger(["reactor-api", "create-schema"]);
-/**
- * Revision type - matches the definition in reactor/schema.graphql.
- * Used by PHDocument and document mutation results.
- */
-const RevisionType = `
-  type Revision {
-    scope: String!
-    revision: Int!
-  }
-`;
-/**
- * Strip scalar definitions from a DocumentNode to avoid duplicates
- * when combining with other schemas that define the same scalars.
- */
-const stripScalarDefinitions = (doc) => {
-    const filteredDefinitions = doc.definitions.filter((def) => def.kind !== Kind.SCALAR_TYPE_DEFINITION);
-    return print({ kind: Kind.DOCUMENT, definitions: filteredDefinitions });
-};
-export const buildSubgraphSchemaModule = (documentModels, resolvers, typeDefs) => {
-    const newResolvers = {
-        ...resolvers,
-        JSONObject: GraphQLJSONObject,
-    };
-    return {
-        typeDefs: getDocumentModelTypeDefs(documentModels, typeDefs),
-        resolvers: newResolvers,
-    };
-};
-export const createSchema = (documentModels, resolvers, typeDefs) => {
-    return buildSubgraphSchema(buildSubgraphSchemaModule(documentModels, resolvers, typeDefs));
-};
-/**
- * Create a merged GraphQL schema from multiple subgraph modules.
- * Uses buildSubgraphSchema's array overload to combine type definitions
- * and resolvers from multiple subgraphs into a single executable schema.
- */
-export const createMergedSchema = (modules) => {
-    return buildSubgraphSchema(modules);
-};
-export function getDocumentModelSchemaName(documentModel) {
-    return pascalCase(documentModel.name.replaceAll("/", " "));
-}
-export const getDocumentModelTypeDefs = (documentModels, typeDefs) => {
-    let dmSchema = "";
-    const addedDocumentModels = new Set();
-    documentModels.forEach(({ documentModel }) => {
-        const dmSchemaName = getDocumentModelSchemaName(documentModel.global);
-        if (addedDocumentModels.has(dmSchemaName)) {
-            logger.debug(`Skipping document model with duplicate name: ${dmSchemaName}`);
-            return;
-        }
-        addedDocumentModels.add(dmSchemaName);
-        // Use only the latest specification to avoid duplicate type definitions
-        // when a document model has multiple versions (e.g. v1, v2).
-        const latestSpec = documentModel.global.specifications.at(-1);
-        const globalSchema = latestSpec?.state.global.schema ?? "";
-        const localSchema = latestSpec?.state.local.schema ?? "";
-        let tmpDmSchema = `
-          ${globalSchema
-            .replaceAll("scalar DateTime", "")
-            .replaceAll(/input (.*?) {[\s\S]*?}/g, "")};
-
-          ${localSchema
-            .replaceAll("scalar DateTime", "")
-            .replaceAll(/input (.*?) {[\s\S]*?}/g, "")
-            .replaceAll("type AccountSnapshotLocalState", "")
-            .replaceAll("type BudgetStatementLocalState", "")
-            .replaceAll("type ScopeFrameworkLocalState", "")};
-
-    \n`;
-        const found = tmpDmSchema.match(/(type|enum|union|interface)\s+(\w+)[\s{]/g);
-        const trimmedFound = found?.map((f) => f
-            .replaceAll("type ", "")
-            .replaceAll("enum ", "")
-            .replaceAll("union ", "")
-            .replaceAll("interface ", "")
-            .replaceAll("{", "")
-            .trim());
-        trimmedFound?.forEach((f) => {
-            // Create a regex that matches the type name with proper boundaries
-            const typeRegex = new RegExp(
-            // Match type references in various GraphQL contexts
-            `(?<![_A-Za-z0-9])(${f})(?![_A-Za-z0-9])|` + // Basic type references
-                `\\[(${f})\\]|` + // Array types without nullability
-                `\\[(${f})!\\]|` + // Array of non-null types
-                `\\[(${f})\\]!|` + // Non-null array of types
-                `\\[(${f})!\\]!`, // Non-null array of non-null types
-            "g");
-            tmpDmSchema = tmpDmSchema.replace(typeRegex, (match, p1, p2, p3, p4, p5) => {
-                // If it's an array type, preserve the brackets and ! while replacing the type name
-                if (match.startsWith("[")) {
-                    return match.replace(p2 || p3 || p4 || p5, `${dmSchemaName}_${p2 || p3 || p4 || p5}`);
-                }
-                // Basic type reference
-                return `${dmSchemaName}_${p1}`;
-            });
-        });
-        dmSchema += tmpDmSchema;
-        dmSchema += `
-    type ${dmSchemaName} implements IDocument {
-              id: String!
-              name: String!
-              documentType: String!
-              operations(skip: Int, first: Int): [Operation!]!
-              revision: Int!
-              createdAtUtcIso: DateTime!
-              lastModifiedAtUtcIso: DateTime!
-              ${dmSchemaName !== "DocumentModel" ? `initialState: ${dmSchemaName}_${dmSchemaName}State!` : ""}
-              ${dmSchemaName !== "DocumentModel" ? `state: ${dmSchemaName}_${dmSchemaName}State!` : ""}
-              stateJSON: JSONObject
-          }\n`;
-    });
-    // add the mutation and query types
-    const schema = gql `
-    scalar JSONObject
-    ${scalarsTypeDefs.join("\n").replaceAll(";", "")}
-
-    type PHOperationContext {
-      signer: Signer
-    }
-
-    type Signer {
-      user: SignerUser
-      app: SignerApp
-      signatures: [String!]!
-    }
-
-    type SignerUser {
-      address: String!
-      networkId: String!
-      chainId: Int!
-    }
-
-    type SignerApp {
-      name: String!
-      key: String!
-    }
-
-    type Operation {
-      id: String!
-      type: String!
-      index: Int!
-      timestampUtcMs: DateTime!
-      hash: String!
-      skip: Int
-      inputText: String
-      error: String
-      context: PHOperationContext
-    }
-
-    interface IDocument {
-      id: String!
-      name: String!
-      documentType: String!
-      revision: Int!
-      createdAtUtcIso: DateTime!
-      lastModifiedAtUtcIso: DateTime!
-      operations(first: Int, skip: Int): [Operation!]!
-      stateJSON: JSONObject
-    }
-    ${dmSchema.replaceAll(";", "")}
-
-    type GqlDocument implements IDocument {
-      id: String!
-      name: String!
-      documentType: String!
-      revision: Int!
-      createdAtUtcIso: DateTime!
-      lastModifiedAtUtcIso: DateTime!
-      operations(first: Int, skip: Int): [Operation!]!
-      stateJSON: JSONObject
-    }
-
-    type DriveDocument implements IDocument {
-      id: String!
-      name: String!
-      documentType: String!
-      revision: Int!
-      createdAtUtcIso: DateTime!
-      lastModifiedAtUtcIso: DateTime!
-      operations(first: Int, skip: Int): [Operation!]!
-      stateJSON: JSONObject
-    }
-
-    ${stripScalarDefinitions(typeDefs)}
-  `;
-    return schema;
-};
-/**
- * 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 ", "")
-        .replaceAll("{", "")
-        .trim());
-}
-/**
- * Extract input type definitions from a GraphQL schema.
- * @param {string} schema - GraphQL schema string
- * @param {Set<string>} excludeTypeNames - Type names to exclude from extraction
- * @returns {string} All input type definitions as a string
- */
-function extractInputTypeDefinitions(schema, excludeTypeNames = new Set()) {
-    // Match input type blocks: input TypeName { ... }
-    const inputTypeRegex = /input\s+(\w+)\s*\{[^}]*\}/g;
-    const matches = [];
-    let match;
-    while ((match = inputTypeRegex.exec(schema)) !== null) {
-        const typeName = match[1];
-        // Skip if this type name is in the exclusion set
-        if (!excludeTypeNames.has(typeName)) {
-            matches.push(match[0]);
-        }
-    }
-    if (matches.length === 0)
-        return "";
-    return matches.join("\n\n");
-}
-/**
- * Extract the root state type name from a scope's GraphQL schema.
- * Uses the naming convention: {DocumentName}State for global,
- * {DocumentName}{PascalScope}State for other scopes (e.g., DocumentDriveLocalState).
- * Falls back to the last ObjectTypeDefinition (root types are conventionally last).
- */
-function extractRootTypeName(schema, documentName, scopeName) {
-    try {
-        const ast = parse(schema);
-        // Try conventions:
-        // 1. {DocumentName}State for global, {DocumentName}{Scope}State otherwise
-        // 2. {DocumentName}GlobalState (DocumentModel uses this variant)
-        const scopeSuffix = scopeName === "global" ? "" : pascalCase(scopeName);
-        const candidates = [
-            `${documentName}${scopeSuffix}State`,
-            `${documentName}${pascalCase(scopeName)}State`,
-        ];
-        let lastObjectType = null;
-        for (const def of ast.definitions) {
-            if (def.kind === Kind.OBJECT_TYPE_DEFINITION) {
-                if (candidates.includes(def.name.value)) {
-                    return def.name.value;
-                }
-                lastObjectType = def.name.value;
-            }
-        }
-        // Fallback: last object type (root state types are defined last by convention)
-        return lastObjectType;
-    }
-    catch {
-        // ignore parse errors
-    }
-    return null;
-}
-/**
- * Convert a GraphQL output type AST node to an optional input type string.
- * Strips non-null markers and converts object type references to Input suffix.
- */
-function convertTypeNodeToInput(typeNode, objectNames, unionNames, interfaceNames) {
-    if (typeNode.kind === Kind.NON_NULL_TYPE && typeNode.type) {
-        return convertTypeNodeToInput(typeNode.type, objectNames, unionNames, interfaceNames);
-    }
-    if (typeNode.kind === Kind.LIST_TYPE && typeNode.type) {
-        const inner = convertTypeNodeToInput(typeNode.type, objectNames, unionNames, interfaceNames);
-        return `[${inner}]`;
-    }
-    if (typeNode.kind === Kind.NAMED_TYPE && typeNode.name) {
-        const name = typeNode.name.value;
-        if (objectNames.has(name))
-            return `${name}Input`;
-        if (unionNames.has(name) || interfaceNames.has(name))
-            return "JSONObject";
-        return name;
-    }
-    return "JSONObject";
-}
-/**
- * Generate GraphQL input type definitions from a state schema string.
- * Converts output type definitions to input types with all fields optional.
- * - Object type references get Input suffix
- * - Union/interface references become JSONObject
- * - Enums and scalars remain unchanged
- */
-function generateStateInputTypes(stateSchema, excludeTypeNames) {
-    if (!stateSchema || !stateSchema.trim())
-        return "";
-    let ast;
-    try {
-        ast = parse(stateSchema);
-    }
-    catch {
-        return "";
-    }
-    const enumNames = new Set();
-    const unionNames = new Set();
-    const interfaceNames = new Set();
-    const objectNames = new Set();
-    const existingInputNames = new Set();
-    for (const def of ast.definitions) {
-        switch (def.kind) {
-            case Kind.ENUM_TYPE_DEFINITION:
-                enumNames.add(def.name.value);
-                break;
-            case Kind.UNION_TYPE_DEFINITION:
-                unionNames.add(def.name.value);
-                break;
-            case Kind.INTERFACE_TYPE_DEFINITION:
-                interfaceNames.add(def.name.value);
-                break;
-            case Kind.OBJECT_TYPE_DEFINITION:
-                objectNames.add(def.name.value);
-                break;
-            case Kind.INPUT_OBJECT_TYPE_DEFINITION:
-                existingInputNames.add(def.name.value);
-                break;
-        }
-    }
-    const inputTypes = [];
-    for (const def of ast.definitions) {
-        if (def.kind !== Kind.OBJECT_TYPE_DEFINITION)
-            continue;
-        // Skip if an input type with the same name already exists in the schema
-        // or in operation schemas (to avoid duplicates with moduleSchemas)
-        const inputName = `${def.name.value}Input`;
-        if (existingInputNames.has(inputName))
-            continue;
-        if (excludeTypeNames?.has(inputName))
-            continue;
-        const fields = def.fields ?? [];
-        if (fields.length === 0)
-            continue;
-        const inputFields = fields.map((field) => {
-            const fieldName = field.name.value;
-            const fieldType = convertTypeNodeToInput(field.type, objectNames, unionNames, interfaceNames);
-            return `  ${fieldName}: ${fieldType}`;
-        });
-        inputTypes.push(`input ${def.name.value}Input {\n${inputFields.join("\n")}\n}`);
-    }
-    return inputTypes.join("\n\n");
-}
-/**
- * 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;
-}
-/**
- * Generate a GraphQL schema for a document model.
- *
- * @param documentModel - The document model global state
- * @param options - Schema generation options
- * @returns GraphQL DocumentNode
- */
-export function generateDocumentModelSchema(documentModel, options = {}) {
-    const { useNewApi = false } = options;
-    const specification = documentModel.specifications.at(-1);
-    const documentName = getDocumentModelSchemaName(documentModel);
-    const globalStateSchema = specification?.state.global.schema;
-    const localStateSchema = specification?.state.local.schema;
-    const globalStateTypeNames = extractTypeNames(globalStateSchema ?? "");
-    const localStateTypeNames = extractTypeNames(localStateSchema ?? "");
-    const stateTypeNames = [...globalStateTypeNames, ...localStateTypeNames];
-    // Collect ALL type names from all operations' schemas
-    const allOperationTypeNames = specification?.modules.flatMap((module) => module.operations.flatMap((op) => extractTypeNames(op.schema ?? ""))) ?? [];
-    // Combine state types and all operation types for prefixing
-    const allTypeNames = [
-        ...new Set([...stateTypeNames, ...allOperationTypeNames]),
-    ];
-    // Extract input type definitions from state schema, excluding operation-specific inputs
-    // (those are already defined in op.schema)
-    const operationInputTypeNames = new Set(allOperationTypeNames);
-    const stateInputTypes = extractInputTypeDefinitions(globalStateSchema ?? "", operationInputTypeNames);
-    const prefixedStateInputTypes = applyGraphQLTypePrefixes(stateInputTypes, documentName, allTypeNames);
-    // Helper to check if schema has actual GraphQL type definitions
-    const hasValidSchema = (schema) => !!(schema && /\b(input|type|enum|union|interface)\s+\w+/.test(schema));
-    // Process state schema types (remove input types, clean up, and prefix)
-    const stateSchemaTypes = globalStateSchema
-        ? applyGraphQLTypePrefixes(globalStateSchema
-            .replaceAll("scalar DateTime", "")
-            .replaceAll(/input (.*?) {[\s\S]*?}/g, ""), documentName, allTypeNames)
-        : "";
-    if (useNewApi) {
-        // New API: flat queries, typed state, async mutations
-        return generateNewApiSchema(documentName, specification, stateSchemaTypes, prefixedStateInputTypes, allTypeNames, hasValidSchema);
-    }
-    // Legacy API
-    return generateLegacyApiSchema(documentName, specification, prefixedStateInputTypes, allTypeNames, hasValidSchema);
-}
-/**
- * Generate legacy API schema with nested queries
- */
-function generateLegacyApiSchema(documentName, specification, prefixedStateInputTypes, allTypeNames, hasValidSchema) {
-    const createDocumentMutation = `${documentName}_createDocument(name:String!, driveId:String): String`;
-    const operationMutations = specification?.modules
-        .flatMap((module) => module.operations
-        .filter((op) => op.name && hasValidSchema(op.schema))
-        .map((op) => `${documentName}_${camelCase(op.name)}(
-            driveId: String, docId: PHID, input: ${documentName}_${pascalCase(op.name)}Input): Int`))
-        .join("\n        ") ?? "";
-    const moduleSchemas = specification?.modules
-        .filter((module) => module.operations.some((op) => hasValidSchema(op.schema)))
-        .map((module) => `"""
-       Module: ${pascalCase(module.name)}
-       """
-       ${module.operations
-        .filter((op) => hasValidSchema(op.schema))
-        .map((op) => applyGraphQLTypePrefixes(op.schema ?? "", documentName, allTypeNames))
-        .join("\n  ")}`)
-        .join("\n") ?? "";
-    return gql `
-    """
-    Queries: ${documentName} Document
-    """
-
-    type ${documentName}Queries {
-        getDocument(docId: PHID!, driveId: PHID): ${documentName}
-        getDocuments(driveId: String!): [${documentName}!]
-    }
-
-    type Query {
-        ${documentName}: ${documentName}Queries
-    }
-
-    """
-    Mutations: ${documentName}
-    """
-    type Mutation {
-        ${createDocumentMutation}
-
-        ${operationMutations}
-    }
-
-    ${prefixedStateInputTypes
-        ? `"""
-    Input Types from State Schema
-    """
-    ${prefixedStateInputTypes}`
-        : ""}
-
-    ${moduleSchemas}`;
-}
-/**
- * Generate new API schema with flat queries, typed state, and async mutations.
- * Note: State schema types are NOT included here because they are already defined
- * in getDocumentModelTypeDefs() which is used during schema composition.
- * Including them here would cause duplicate type definitions.
- */
-function generateNewApiSchema(documentName, specification, _stateSchemaTypes, prefixedStateInputTypes, allTypeNames, hasValidSchema) {
-    // Use full state type for all document models
-    const stateType = `${documentName}_FullState!`;
-    // Shared base types for document state structure (same for all document types)
-    const sharedBaseTypes = `
-    """Hash configuration for document state"""
-    type ${documentName}_PHHashConfig {
-      algorithm: String!
-      encoding: String!
-    }
-
-    """Document scope state (same for all document types)"""
-    type ${documentName}_PHDocumentScopeState {
-      version: Int!
-      hash: ${documentName}_PHHashConfig!
-      isDeleted: Boolean
-      deletedAtUtcIso: String
-      deletedBy: String
-      deletionReason: String
-    }
-  `;
-    // Full state type with all scopes (auth, document, global, local)
-    // Note: DocumentModel uses different naming convention (GlobalState suffix instead of State)
-    // For local state, check if the specification defines a local state type
-    const localSchema = specification?.state.local.schema ?? "";
-    const hasLocalStateType = localSchema.includes(`type ${documentName}LocalState`);
-    const globalStateType = documentName === "DocumentModel"
-        ? `${documentName}_${documentName}GlobalState!`
-        : `${documentName}_${documentName}State!`;
-    const localStateType = !hasLocalStateType
-        ? "JSONObject!"
-        : `${documentName}_${documentName}LocalState!`;
-    const fullStateType = `
-    """Full state with all scopes for ${documentName}"""
-    type ${documentName}_FullState {
-      auth: JSONObject!
-      document: ${documentName}_PHDocumentScopeState!
-      global: ${globalStateType}
-      local: ${localStateType}
-    }
-  `;
-    // Common input types - use extend to avoid conflicts with other subgraphs
-    const commonInputTypes = `
-    input ${documentName}_ViewFilterInput {
-      branch: String
-      scopes: [String!]
-    }
-
-    input ${documentName}_PagingInput {
-      limit: Int
-      offset: Int
-      cursor: String
-    }
-
-    input ${documentName}_SearchFilterInput {
-      parentId: String
-      identifiers: [String!]
-    }
-  `;
-    // Revision type - imported from shared-schema.ts for consistency with ReactorSubgraph
-    // Must be defined in each subgraph for Apollo Federation
-    const revisionType = RevisionType;
-    // Result types with typed state (or JSONObject for DocumentModel)
-    // The state type (${documentName}_${documentName}State) is defined in getDocumentModelTypeDefs()
-    // Uses revisionsList with shared Revision type to match ReactorSubgraph pattern
-    const resultTypes = `
-    """
-    Mutation result type for ${documentName} operations with typed state.
-    Matches ReactorSubgraph PHDocument pattern with revisionsList.
-    """
-    type ${documentName}MutationResult {
-      id: String!
-      slug: String
-      preferredEditor: String
-      name: String!
-      documentType: String!
-      state: ${stateType}
-      revisionsList: [Revision!]!
-      createdAtUtcIso: DateTime!
-      lastModifiedAtUtcIso: DateTime!
-    }
-
-    """
-    Document with children for ${documentName}
-    """
-    type ${documentName}_DocumentWithChildren {
-      document: ${documentName}MutationResult!
-      childIds: [String!]!
-    }
-
-    """
-    Paginated result type for ${documentName} documents
-    """
-    type ${documentName}_DocumentResultPage {
-      items: [${documentName}MutationResult!]!
-      totalCount: Int!
-      hasNextPage: Boolean!
-      hasPreviousPage: Boolean!
-      cursor: String
-    }
-  `;
-    // Queries nested under ${documentName} namespace
-    const queries = `
-    type ${documentName}Queries {
-      """Get a specific ${documentName} document by identifier"""
-      document(identifier: String!, view: ${documentName}_ViewFilterInput): ${documentName}_DocumentWithChildren
-
-      """Get all ${documentName} documents (paged)"""
-      documents(paging: ${documentName}_PagingInput): ${documentName}_DocumentResultPage!
-
-      """Find ${documentName} documents by search criteria"""
-      findDocuments(search: ${documentName}_SearchFilterInput, view: ${documentName}_ViewFilterInput, paging: ${documentName}_PagingInput): ${documentName}_DocumentResultPage!
-
-      """Get children of a ${documentName} document"""
-      documentChildren(parentIdentifier: String!, view: ${documentName}_ViewFilterInput, paging: ${documentName}_PagingInput): ${documentName}_DocumentResultPage!
-
-      """Get parents of a ${documentName} document"""
-      documentParents(childIdentifier: String!, view: ${documentName}_ViewFilterInput, paging: ${documentName}_PagingInput): ${documentName}_DocumentResultPage!
-    }
-  `;
-    // Generate initial state input types for each scope
-    let initialStateInputSchema = "";
-    if (specification) {
-        const scopeFields = [];
-        const generatedInputTypeParts = [];
-        for (const [scopeName, scopeState] of Object.entries(specification.state)) {
-            const schema = scopeState.schema ?? "";
-            if (hasValidSchema(schema)) {
-                const rootTypeName = extractRootTypeName(schema, documentName, scopeName);
-                if (!rootTypeName) {
-                    scopeFields.push(`  ${scopeName}: JSONObject`);
-                    continue;
-                }
-                const scopeInputTypes = generateStateInputTypes(schema, new Set(allTypeNames));
-                if (!scopeInputTypes) {
-                    scopeFields.push(`  ${scopeName}: JSONObject`);
-                    continue;
-                }
-                const prefixedScopeInputTypes = applyGraphQLTypePrefixes(scopeInputTypes, documentName, allTypeNames);
-                scopeFields.push(`  ${scopeName}: ${documentName}_${rootTypeName}Input`);
-                generatedInputTypeParts.push(prefixedScopeInputTypes);
-            }
-            else {
-                scopeFields.push(`  ${scopeName}: JSONObject`);
-            }
-        }
-        if (scopeFields.length > 0) {
-            const inputTypeDefs = generatedInputTypeParts.join("\n\n");
-            const wrapper = `input ${documentName}_InitialStateInput {\n${scopeFields.join("\n")}\n}`;
-            initialStateInputSchema = inputTypeDefs
-                ? `${inputTypeDefs}\n\n${wrapper}`
-                : wrapper;
-        }
-    }
-    // Mutations nested under ${documentName} namespace
-    const createDocumentMutation = initialStateInputSchema
-        ? `createDocument(name: String!, parentIdentifier: String, slug: String, preferredEditor: String, initialState: ${documentName}_InitialStateInput): ${documentName}MutationResult!`
-        : `createDocument(name: String!, parentIdentifier: String, preferredEditor: String): ${documentName}MutationResult!`;
-    const createEmptyDocumentMutation = `createEmptyDocument(parentIdentifier: String): ${documentName}MutationResult!`;
-    const operationMutations = specification?.modules
-        .flatMap((module) => module.operations
-        .filter((op) => op.name && hasValidSchema(op.schema))
-        .flatMap((op) => [
-        // Sync mutation
-        `${camelCase(op.name)}(docId: PHID!, input: ${documentName}_${pascalCase(op.name)}Input!): ${documentName}MutationResult!`,
-        // Async mutation
-        `${camelCase(op.name)}Async(docId: PHID!, input: ${documentName}_${pascalCase(op.name)}Input!): String!`,
-    ]))
-        .join("\n        ") ?? "";
-    const moduleSchemas = specification?.modules
-        .filter((module) => module.operations.some((op) => hasValidSchema(op.schema)))
-        .map((module) => `"""
-       Module: ${pascalCase(module.name)}
-       """
-       ${module.operations
-        .filter((op) => hasValidSchema(op.schema))
-        .map((op) => applyGraphQLTypePrefixes(op.schema ?? "", documentName, allTypeNames))
-        .join("\n  ")}`)
-        .join("\n") ?? "";
-    return gql `
-    scalar DateTime
-    scalar JSONObject
-
-    ${revisionType}
-
-    ${sharedBaseTypes}
-
-    ${fullStateType}
-
-    ${commonInputTypes}
-
-    ${resultTypes}
-
-    """
-    Queries: ${documentName} Document
-    """
-    ${queries}
-
-    """
-    Mutations: ${documentName}
-    """
-    type ${documentName}Mutations {
-        ${createDocumentMutation}
-        ${createEmptyDocumentMutation}
-
-        ${operationMutations}
-    }
-
-    type Query {
-      ${documentName}: ${documentName}Queries!
-    }
-
-    type Mutation {
-      ${documentName}: ${documentName}Mutations!
-    }
-
-    ${prefixedStateInputTypes
-        ? `"""
-    Input Types from State Schema
-    """
-    ${prefixedStateInputTypes}`
-        : ""}
-
-    ${initialStateInputSchema
-        ? `"""
-    Input Types for Initial State
-    """
-    ${initialStateInputSchema}`
-        : ""}
-
-    ${moduleSchemas}`;
-}
-//# sourceMappingURL=create-schema.js.map