@graphcommerce/graphql-codegen-markdown-docs 6.0.0-canary.20

package/dist/MarkdownVisitor.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarkdownVisitor = void 0;
+/* eslint-disable @typescript-eslint/no-use-before-define */
+/* eslint-disable prefer-template */
+const typescript_1 = require("@graphql-codegen/typescript");
+const visitor_plugin_common_1 = require("@graphql-codegen/visitor-plugin-common");
+const graphql_1 = require("./graphql");
+const importZod = `import { z } from 'zod'`;
+const anySchema = `definedNonNullAnySchema`;
+const MarkdownVisitor = (schema, config) => {
+    const tsVisitor = new typescript_1.TsVisitor(schema, config);
+    const importTypes = [];
+    return {
+        buildImports: () => 
+        // if (config.importFrom && importTypes.length > 0) {
+        //   return [importZod, `import { ${importTypes.join(', ')} } from '${config.importFrom}'`]
+        // }
+        [importZod],
+        initialEmit: () => '\n' +
+            [
+                new visitor_plugin_common_1.DeclarationBlock({})
+                    .asKind('type')
+                    .withName('Properties<T>')
+                    .withContent(['Required<{', '  [K in keyof T]: z.ZodType<T[K], any, T[K]>;', '}>'].join('\n')).string,
+                // Unfortunately, zod doesn’t provide non-null defined any schema.
+                // This is a temporary hack until it is fixed.
+                // see: https://github.com/colinhacks/zod/issues/884
+                new visitor_plugin_common_1.DeclarationBlock({}).asKind('type').withName('definedNonNullAny').withContent('{}')
+                    .string,
+                new visitor_plugin_common_1.DeclarationBlock({})
+                    .export()
+                    .asKind('const')
+                    .withName(`isDefinedNonNullAny`)
+                    .withContent(`(v: any): v is definedNonNullAny => v !== undefined && v !== null`).string,
+                new visitor_plugin_common_1.DeclarationBlock({})
+                    .export()
+                    .asKind('const')
+                    .withName(`${anySchema}`)
+                    .withContent(`z.any().refine((v) => isDefinedNonNullAny(v))`).string,
+            ].join('\n'),
+        InputObjectTypeDefinition: (node) => {
+            const name = tsVisitor.convertName(node.name.value);
+            importTypes.push(name);
+            const shape = node.fields
+                ?.map((field) => generateFieldZodSchema(config, tsVisitor, schema, field, 2))
+                .join(',\n');
+            return new visitor_plugin_common_1.DeclarationBlock({})
+                .export()
+                .asKind('function')
+                .withName(`${name}Schema(): z.ZodObject<Properties<${name}>>`)
+                .withBlock([(0, visitor_plugin_common_1.indent)(`return z.object<Properties<${name}>>({`), shape, (0, visitor_plugin_common_1.indent)('})')].join('\n')).string;
+        },
+        ObjectTypeDefinition: ObjectTypeDefinitionBuilder(true, (node) => {
+            const name = tsVisitor.convertName(node.name.value);
+            importTypes.push(name);
+            const shape = node.fields
+                ?.map((field) => generateFieldZodSchema(config, tsVisitor, schema, field, 2))
+                .join(',\n');
+            return new visitor_plugin_common_1.DeclarationBlock({})
+                .export()
+                .asKind('function')
+                .withName(`${name}Schema(): z.ZodObject<Properties<${name}>>`)
+                .withBlock([
+                (0, visitor_plugin_common_1.indent)(`return z.object<Properties<${name}>>({`),
+                (0, visitor_plugin_common_1.indent)(`__typename: z.literal('${node.name.value}').optional(),`, 2),
+                shape,
+                (0, visitor_plugin_common_1.indent)('})'),
+            ].join('\n')).string;
+        }),
+        EnumTypeDefinition: (node) => {
+            const enumname = tsVisitor.convertName(node.name.value);
+            importTypes.push(enumname);
+            if (config.enumsAsTypes) {
+                return new visitor_plugin_common_1.DeclarationBlock({})
+                    .export()
+                    .asKind('const')
+                    .withName(`${enumname}Schema`)
+                    .withContent(`z.enum([${node.values
+                    ?.map((enumOption) => `'${enumOption.name.value}'`)
+                    .join(', ')}])`).string;
+            }
+            return new visitor_plugin_common_1.DeclarationBlock({})
+                .export()
+                .asKind('const')
+                .withName(`${enumname}Schema`)
+                .withContent(`z.nativeEnum(${enumname})`).string;
+        },
+        UnionTypeDefinition: (node) => {
+            if (!node.types)
+                return undefined;
+            const unionName = tsVisitor.convertName(node.name.value);
+            const unionElements = node.types
+                .map((t) => `${tsVisitor.convertName(t.name.value)}Schema()`)
+                .join(', ');
+            const unionElementsCount = node.types.length ?? 0;
+            const union = unionElementsCount > 1
+                ? (0, visitor_plugin_common_1.indent)(`return z.union([${unionElements}])`)
+                : (0, visitor_plugin_common_1.indent)(`return ${unionElements}`);
+            return new visitor_plugin_common_1.DeclarationBlock({})
+                .export()
+                .asKind('function')
+                .withName(`${unionName}Schema()`)
+                .withBlock(union).string;
+        },
+    };
+};
+exports.MarkdownVisitor = MarkdownVisitor;
+const generateFieldZodSchema = (config, tsVisitor, schema, field, indentCount) => {
+    const gen = generateFieldTypeZodSchema(config, tsVisitor, schema, field, field.type);
+    return (0, visitor_plugin_common_1.indent)(`${field.name.value}: ${maybeLazy(field.type, gen)}`, indentCount);
+};
+const generateFieldTypeZodSchema = (config, tsVisitor, schema, field, type, parentType) => {
+    if ((0, graphql_1.isListType)(type)) {
+        const gen = generateFieldTypeZodSchema(config, tsVisitor, schema, field, type.type, type);
+        if (!(0, graphql_1.isNonNullType)(parentType)) {
+            const arrayGen = `z.array(${maybeLazy(type.type, gen)})`;
+            const maybeLazyGen = applyDirectives(config, field, arrayGen);
+            return `${maybeLazyGen}.nullish()`;
+        }
+        return `z.array(${maybeLazy(type.type, gen)})`;
+    }
+    if ((0, graphql_1.isNonNullType)(type)) {
+        const gen = generateFieldTypeZodSchema(config, tsVisitor, schema, field, type.type, type);
+        return maybeLazy(type.type, gen);
+    }
+    if ((0, graphql_1.isNamedType)(type)) {
+        const gen = generateNameNodeZodSchema(config, tsVisitor, schema, type.name);
+        if ((0, graphql_1.isListType)(parentType)) {
+            return `${gen}.nullable()`;
+        }
+        const appliedDirectivesGen = applyDirectives(config, field, gen);
+        if ((0, graphql_1.isNonNullType)(parentType)) {
+            // if (config.notAllowEmptyString === true) {
+            //   const tsType = tsVisitor.scalars[type.name.value]
+            //   if (tsType === 'string') return `${appliedDirectivesGen}.min(1)`
+            // }
+            return appliedDirectivesGen;
+        }
+        if ((0, graphql_1.isListType)(parentType)) {
+            return `${appliedDirectivesGen}.nullable()`;
+        }
+        return `${appliedDirectivesGen}.nullish()`;
+    }
+    console.warn('unhandled type:', type);
+    return '';
+};
+const applyDirectives = (config, field, gen) => 
+// if (config.directives && field.directives) {
+//   const formatted = formatDirectiveConfig(config.directives)
+//   return gen + buildApi(formatted, field.directives)
+// }
+gen;
+const generateNameNodeZodSchema = (config, tsVisitor, schema, node) => {
+    const typ = schema.getType(node.value);
+    if (typ?.astNode?.kind === 'InputObjectTypeDefinition') {
+        const enumName = tsVisitor.convertName(typ.astNode.name.value);
+        return `${enumName}Schema()`;
+    }
+    if (typ?.astNode?.kind === 'ObjectTypeDefinition') {
+        const enumName = tsVisitor.convertName(typ.astNode.name.value);
+        return `${enumName}Schema()`;
+    }
+    if (typ?.astNode?.kind === 'EnumTypeDefinition') {
+        const enumName = tsVisitor.convertName(typ.astNode.name.value);
+        return `${enumName}Schema`;
+    }
+    if (typ?.astNode?.kind === 'UnionTypeDefinition') {
+        const enumName = tsVisitor.convertName(typ.astNode.name.value);
+        return `${enumName}Schema()`;
+    }
+    return zod4Scalar(config, tsVisitor, node.value);
+};
+const maybeLazy = (type, schema) => {
+    if ((0, graphql_1.isNamedType)(type) && (0, graphql_1.isInput)(type.name.value)) {
+        return `z.lazy(() => ${schema})`;
+    }
+    return schema;
+};
+const zod4Scalar = (config, tsVisitor, scalarName) => {
+    const tsType = tsVisitor.scalars[scalarName];
+    switch (tsType) {
+        case 'string':
+            return `z.string()`;
+        case 'number':
+            return `z.number()`;
+        case 'boolean':
+            return `z.boolean()`;
+    }
+    console.warn('unhandled scalar name:', scalarName);
+    return anySchema;
+};

package/dist/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/graphql.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectTypeDefinitionBuilder = exports.isInput = exports.isNamedType = exports.isNonNullType = exports.isListType = void 0;
+const isListType = (typ) => typ?.kind === 'ListType';
+exports.isListType = isListType;
+const isNonNullType = (typ) => typ?.kind === 'NonNullType';
+exports.isNonNullType = isNonNullType;
+const isNamedType = (typ) => typ?.kind === 'NamedType';
+exports.isNamedType = isNamedType;
+const isInput = (kind) => kind.includes('Input');
+exports.isInput = isInput;
+const ObjectTypeDefinitionBuilder = (useObjectTypes, callback) => {
+    if (!useObjectTypes)
+        return undefined;
+    return (node) => {
+        if (/^(Query|Mutation|Subscription)$/.test(node.name.value)) {
+            return undefined;
+        }
+        return callback(node);
+    };
+};
+exports.ObjectTypeDefinitionBuilder = ObjectTypeDefinitionBuilder;

package/dist/index.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
+const graphql_1 = require("graphql");
+/** Converts input type to markdown document. */
+const plugin = (schema, _documents, config) => {
+    const astNode = (0, plugin_helpers_1.getCachedDocumentNodeFromSchema)(schema);
+    const enumStings = new Map();
+    const descriptionText = (node) => {
+        if (!node.description) {
+            console.warn(`Missing description for ${node.name}`);
+        }
+        return node.description ? `\n\n${node.description}` : '';
+    };
+    const res = (0, graphql_1.visit)(astNode, {
+        Document: {
+            leave: (node) => `<!-- auto generated -->${node.definitions.filter(Boolean).join('\n')}`,
+        },
+        Name: { leave: (node) => node.value },
+        NamedType: { leave: (node) => node.name },
+        StringValue: { leave: (node) => node.value },
+        ListType: { leave: (node) => `[${node.type}]` },
+        NonNullType: { leave: (node) => `${node.type}!` },
+        InputValueDefinition: {
+            leave: (node) => {
+                const { type } = node;
+                return `\`${node.name}: ${type}\`${descriptionText(node)}`;
+            },
+        },
+        InputObjectTypeDefinition: {
+            enter: (node) => ({
+                ...node,
+                // Move required fields to the top.
+                fields: [...(node.fields ?? [])].sort((a, b) => a.type.kind === 'NonNullType' && b.type.kind !== 'NonNullType' ? -1 : 1),
+            }),
+            leave: (node) => `\n## ${node.name}${descriptionText(node)}
+${node.fields?.map((f) => `\n### ${f}`).join('\n')}`,
+        },
+        EnumValueDefinition: {
+            leave: (node) => `${node.name} # ${node.description}`,
+        },
+        EnumTypeDefinition: {
+            leave: (node) => {
+                enumStings.set(node.name, node.values?.join('\n') || '');
+                return '';
+            },
+        },
+    });
+    return {
+        // prepend: buildImports(),
+        content: [res].join('\n'),
+    };
+};
+exports.plugin = plugin;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@graphcommerce/graphql-codegen-markdown-docs",
+  "homepage": "https://www.graphcommerce.org/",
+  "repository": "github:graphcommerce-org/graphcommerce",
+  "version": "6.0.0-canary.20",
+  "sideEffects": false,
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "types": "src/index.ts",
+  "scripts": {
+    "test": "jest",
+    "dev": "tsc -W --preserveWatchOutput",
+    "build": "tsc",
+    "prepack": "tsc"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "prettier": "@graphcommerce/prettier-config-pwa",
+  "eslintConfig": {
+    "extends": "@graphcommerce/eslint-config-pwa",
+    "parserOptions": {
+      "project": "./tsconfig.json"
+    }
+  },
+  "devDependencies": {
+    "@graphcommerce/eslint-config-pwa": "6.0.0-canary.20",
+    "@graphcommerce/prettier-config-pwa": "6.0.0-canary.20",
+    "@graphcommerce/typescript-config-pwa": "6.0.0-canary.20"
+  },
+  "dependencies": {
+    "@graphql-codegen/add": "4.0.0",
+    "@graphql-codegen/plugin-helpers": "4.0.0",
+    "@graphql-codegen/visitor-plugin-common": "3.0.0",
+    "@graphql-tools/utils": "^9.2.1",
+    "@types/parse-filepath": "^1.0.0",
+    "graphql": "16.6.0",
+    "parse-filepath": "^1.0.2"
+  }
+}

package/src/config.ts

@@ -0,0 +1,15 @@
+import type { TypeScriptPluginConfig } from '@graphql-codegen/typescript'
+
+export interface DirectiveConfig {
+  [directive: string]: {
+    [argument: string]: string | string[] | DirectiveObjectArguments
+  }
+}
+
+export interface DirectiveObjectArguments {
+  [matched: string]: string | string[]
+}
+
+export interface MarkdownDocsPluginConfig extends TypeScriptPluginConfig {
+  markdown: boolean
+}

package/src/graphql.ts

@@ -0,0 +1,28 @@
+import {
+  ListTypeNode,
+  NonNullTypeNode,
+  NamedTypeNode,
+  TypeNode,
+  ObjectTypeDefinitionNode,
+} from 'graphql'
+
+export const isListType = (typ?: TypeNode): typ is ListTypeNode => typ?.kind === 'ListType'
+export const isNonNullType = (typ?: TypeNode): typ is NonNullTypeNode => typ?.kind === 'NonNullType'
+export const isNamedType = (typ?: TypeNode): typ is NamedTypeNode => typ?.kind === 'NamedType'
+
+export const isInput = (kind: string) => kind.includes('Input')
+
+type ObjectTypeDefinitionFn = (node: ObjectTypeDefinitionNode) => any
+
+export const ObjectTypeDefinitionBuilder = (
+  useObjectTypes: boolean | undefined,
+  callback: ObjectTypeDefinitionFn,
+): ObjectTypeDefinitionFn | undefined => {
+  if (!useObjectTypes) return undefined
+  return (node) => {
+    if (/^(Query|Mutation|Subscription)$/.test(node.name.value)) {
+      return undefined
+    }
+    return callback(node)
+  }
+}

package/src/index.ts

@@ -0,0 +1,64 @@
+import { PluginFunction, Types } from '@graphql-codegen/plugin-helpers'
+import { getCachedDocumentNodeFromSchema } from '@graphql-codegen/plugin-helpers'
+import { GraphQLSchema, visit } from 'graphql'
+import { MarkdownDocsPluginConfig } from './config'
+
+/** Converts input type to markdown document. */
+export const plugin: PluginFunction<MarkdownDocsPluginConfig, Types.ComplexPluginOutput> = (
+  schema: GraphQLSchema,
+  _documents: Types.DocumentFile[],
+  config: MarkdownDocsPluginConfig,
+): Types.ComplexPluginOutput => {
+  const astNode = getCachedDocumentNodeFromSchema(schema)
+
+  const enumStings = new Map<string, string>()
+
+  const descriptionText = (node: { description?: string; name: string }) => {
+    if (!node.description) {
+      console.warn(`Missing description for ${node.name}`)
+    }
+    return node.description ? `\n\n${node.description}` : ''
+  }
+
+  const res = visit<string>(astNode, {
+    Document: {
+      leave: (node) => `<!-- auto generated -->${node.definitions.filter(Boolean).join('\n')}`,
+    },
+    Name: { leave: (node) => node.value },
+    NamedType: { leave: (node) => node.name }, // String, Boolean, GraphCommerceDebugConfig, etc.
+    StringValue: { leave: (node) => node.value },
+    ListType: { leave: (node) => `[${node.type}]` },
+    NonNullType: { leave: (node) => `${node.type}!` },
+    InputValueDefinition: {
+      leave: (node) => {
+        const { type } = node
+        return `\`${node.name}: ${type}\`${descriptionText(node)}`
+      },
+    },
+    InputObjectTypeDefinition: {
+      enter: (node) => ({
+        ...node,
+        // Move required fields to the top.
+        fields: [...(node.fields ?? [])].sort((a, b) =>
+          a.type.kind === 'NonNullType' && b.type.kind !== 'NonNullType' ? -1 : 1,
+        ),
+      }),
+      leave: (node) => `\n## ${node.name}${descriptionText(node)}
+${node.fields?.map((f) => `\n### ${f}`).join('\n')}`,
+    },
+    EnumValueDefinition: {
+      leave: (node) => `${node.name} # ${node.description}`,
+    },
+    EnumTypeDefinition: {
+      leave: (node) => {
+        enumStings.set(node.name, node.values?.join('\n') || '')
+        return ''
+      },
+    },
+  })
+
+  return {
+    // prepend: buildImports(),
+    content: [res].join('\n'),
+  }
+}