@graphql-codegen/c-sharp-operations 2.2.13 → 2.2.15-alpha-2cc8b095b.0

package/{index.mjs → esm/visitor.js}

@@ -1,308 +1,14 @@
-import { getCachedDocumentNodeFromSchema, oldVisit } from '@graphql-codegen/plugin-helpers';
-import { Kind, visit, print, isScalarType, isInputObjectType, isEnumType, concatAST } from 'graphql';
-import { indent, indentMultiline, ClientSideBaseVisitor, buildScalarsFromConfig, DocumentMode, getBaseTypeNode } from '@graphql-codegen/visitor-plugin-common';
+import { ClientSideBaseVisitor, DocumentMode, indentMultiline, getBaseTypeNode, indent, buildScalarsFromConfig, } from '@graphql-codegen/visitor-plugin-common';
 import autoBind from 'auto-bind';
-import { extname } from 'path';
-import gql from 'graphql-tag';
-
-const C_SHARP_SCALARS = {
-    ID: 'string',
-    String: 'string',
-    Boolean: 'bool',
-    Int: 'int',
-    Float: 'double',
-    Date: 'DateTime',
-};
-const csharpValueTypes = [
-    'bool',
-    'byte',
-    'sbyte',
-    'char',
-    'decimal',
-    'double',
-    'float',
-    'int',
-    'uint',
-    'long',
-    'ulong',
-    'short',
-    'ushort',
-    'DateTime',
-];
-
-// This file is bundled and inlined.
-function transformComment(comment, indentLevel = 0) {
-    if (!comment) {
-        return '';
-    }
-    if (isStringValueNode(comment)) {
-        comment = comment.value;
-    }
-    comment = comment.trimStart().split('*/').join('*\\/');
-    let lines = comment.split('\n');
-    lines = ['/// <summary>', ...lines.map(line => `/// ${line}`), '/// </summary>'];
-    return lines
-        .map(line => indent(line, indentLevel))
-        .concat('')
-        .join('\n');
-}
-function isStringValueNode(node) {
-    return node && typeof node === 'object' && node.kind === Kind.STRING;
-}
-function isValueType(type) {
-    // Limitation: only checks the list of known built in value types
-    // Eg .NET types and struct types won't be detected correctly
-    return csharpValueTypes.includes(type);
-}
-function getListTypeField(typeNode) {
-    if (typeNode.kind === Kind.LIST_TYPE) {
-        return {
-            required: false,
-            type: getListTypeField(typeNode.type),
-        };
-    }
-    if (typeNode.kind === Kind.NON_NULL_TYPE && typeNode.type.kind === Kind.LIST_TYPE) {
-        return Object.assign(getListTypeField(typeNode.type), {
-            required: true,
-        });
-    }
-    if (typeNode.kind === Kind.NON_NULL_TYPE) {
-        return getListTypeField(typeNode.type);
-    }
-    return undefined;
-}
-function getListTypeDepth(listType) {
-    if (listType) {
-        return getListTypeDepth(listType.type) + 1;
-    }
-    return 0;
-}
-function getListInnerTypeNode(typeNode) {
-    if (typeNode.kind === Kind.LIST_TYPE) {
-        return getListInnerTypeNode(typeNode.type);
-    }
-    if (typeNode.kind === Kind.NON_NULL_TYPE && typeNode.type.kind === Kind.LIST_TYPE) {
-        return getListInnerTypeNode(typeNode.type);
-    }
-    return typeNode;
-}
-function wrapFieldType(fieldType, listTypeField, listType = 'IEnumerable') {
-    if (listTypeField) {
-        const innerType = wrapFieldType(fieldType, listTypeField.type, listType);
-        return `${listType}<${innerType}>`;
-    }
-    return fieldType.innerTypeName;
-}
-
-// This file is bundled and inlined.
-class CSharpDeclarationBlock {
-    constructor() {
-        this._name = null;
-        this._extendStr = [];
-        this._implementsStr = [];
-        this._kind = null;
-        this._access = 'public';
-        this._final = false;
-        this._static = false;
-        this._block = null;
-        this._comment = null;
-        this._nestedClasses = [];
-    }
-    nestedClass(nstCls) {
-        this._nestedClasses.push(nstCls);
-        return this;
-    }
-    access(access) {
-        this._access = access;
-        return this;
-    }
-    asKind(kind) {
-        this._kind = kind;
-        return this;
-    }
-    final() {
-        this._final = true;
-        return this;
-    }
-    static() {
-        this._static = true;
-        return this;
-    }
-    withComment(comment) {
-        if (comment) {
-            this._comment = transformComment(comment, 1);
-        }
-        return this;
-    }
-    withBlock(block) {
-        this._block = block;
-        return this;
-    }
-    extends(extendStr) {
-        this._extendStr = extendStr;
-        return this;
-    }
-    implements(implementsStr) {
-        this._implementsStr = implementsStr;
-        return this;
-    }
-    withName(name) {
-        this._name = typeof name === 'object' ? name.value : name;
-        return this;
-    }
-    get string() {
-        let result = '';
-        if (this._kind) {
-            let name = '';
-            if (this._name) {
-                name = this._name;
-            }
-            if (this._kind === 'namespace') {
-                result += `${this._kind} ${name} `;
-            }
-            else {
-                let extendStr = '';
-                let implementsStr = '';
-                const final = this._final ? ' final' : '';
-                const isStatic = this._static ? ' static' : '';
-                if (this._extendStr.length > 0) {
-                    extendStr = ` : ${this._extendStr.join(', ')}`;
-                }
-                if (this._implementsStr.length > 0) {
-                    implementsStr = ` : ${this._implementsStr.join(', ')}`;
-                }
-                result += `${this._access}${isStatic}${final} ${this._kind} ${name}${extendStr}${implementsStr} `;
-            }
-        }
-        const nestedClasses = this._nestedClasses.length
-            ? this._nestedClasses.map(c => indentMultiline(c.string)).join('\n\n')
-            : null;
-        const before = '{';
-        const after = '}';
-        const block = [before, nestedClasses, this._block, after].filter(f => f).join('\n');
-        result += block;
-        return (this._comment ? this._comment : '') + result + '\n';
-    }
-}
-
-class CSharpFieldType {
-    constructor(fieldType) {
-        Object.assign(this, fieldType);
-    }
-    get innerTypeName() {
-        const nullable = this.baseType.valueType && !this.baseType.required ? '?' : '';
-        return `${this.baseType.type}${nullable}`;
-    }
-    get isOuterTypeRequired() {
-        return this.listType ? this.listType.required : this.baseType.required;
-    }
-}
-
-/**
- * C# keywords
- * https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/
- */
-const csharpKeywords = new Set([
-    'abstract',
-    'as',
-    'base',
-    'bool',
-    'break',
-    'byte',
-    'case',
-    'catch',
-    'char',
-    'checked',
-    'class',
-    'const',
-    'continue',
-    'decimal',
-    'default',
-    'delegate',
-    'do',
-    'double',
-    'else',
-    'enum',
-    'event',
-    'explicit',
-    'extern',
-    'false',
-    'finally',
-    'fixed',
-    'float',
-    'for',
-    'foreach',
-    'goto',
-    'if',
-    'implicit',
-    'in',
-    'int',
-    'interface',
-    'internal',
-    'is',
-    'lock',
-    'long',
-    'namespace',
-    'new',
-    'null',
-    'object',
-    'operator',
-    'out',
-    'override',
-    'params',
-    'private',
-    'protected',
-    'public',
-    'readonly',
-    'record',
-    'ref',
-    'return',
-    'sbyte',
-    'sealed',
-    'short',
-    'sizeof',
-    'stackalloc',
-    'static',
-    'string',
-    'struct',
-    'switch',
-    'this',
-    'throw',
-    'true',
-    'try',
-    'typeof',
-    'uint',
-    'ulong',
-    'unchecked',
-    'unsafe',
-    'ushort',
-    'using',
-    'virtual',
-    'void',
-    'volatile',
-    'while',
-]);
-/**
- * Checks name against list of keywords. If it is, will prefix value with @
- *
- * Note:
- * This class should first invoke the convertName from base-visitor to convert the string or node
- * value according the naming configuration, eg upper or lower case. Then resulting string checked
- * against the list or keywords.
- * However the generated C# code is not yet able to handle fields that are in a different case so
- * the invocation of convertName is omitted purposely.
- */
-function convertSafeName(node) {
-    const name = typeof node === 'string' ? node : node.value;
-    return csharpKeywords.has(name) ? `@${name}` : name;
-}
-
+import { print, visit, Kind, isScalarType, isEnumType, isInputObjectType, } from 'graphql';
+import { getCachedDocumentNodeFromSchema } from '@graphql-codegen/plugin-helpers';
+import { getListInnerTypeNode, C_SHARP_SCALARS, getListTypeField, getListTypeDepth, CSharpFieldType, convertSafeName, isValueType, wrapFieldType, CSharpDeclarationBlock, } from '@graphql-codegen/c-sharp-common';
 const defaultSuffix = 'GQL';
 const R_NAME = /name:\s*"([^"]+)"/;
 function R_DEF(directive) {
     return new RegExp(`\\s+\\@${directive}\\([^)]+\\)`, 'gm');
 }
-class CSharpOperationsVisitor extends ClientSideBaseVisitor {
+export class CSharpOperationsVisitor extends ClientSideBaseVisitor {
     constructor(schema, fragments, rawConfig, documents) {
         super(schema, fragments, rawConfig, {
             namespaceName: rawConfig.namespaceName || 'GraphQLCodeGen',
@@ -711,37 +417,3 @@ ${this._getOperationMethod(node)}
         return indentMultiline(enumDefinition, 2);
     }
 }
-
-const plugin = (schema, documents, config) => {
-    const schemaAST = getCachedDocumentNodeFromSchema(schema);
-    const allAst = concatAST(documents.map(v => v.document).concat(schemaAST));
-    const allFragments = [
-        ...allAst.definitions.filter(d => d.kind === Kind.FRAGMENT_DEFINITION).map(fragmentDef => ({
-            node: fragmentDef,
-            name: fragmentDef.name.value,
-            onType: fragmentDef.typeCondition.name.value,
-            isExternal: false,
-        })),
-        ...(config.externalFragments || []),
-    ];
-    const visitor = new CSharpOperationsVisitor(schema, allFragments, config, documents);
-    const visitorResult = oldVisit(allAst, { leave: visitor });
-    const imports = visitor.getCSharpImports();
-    const openNameSpace = `namespace ${visitor.config.namespaceName} {`;
-    return {
-        prepend: [],
-        content: [imports, openNameSpace, ...visitorResult.definitions.filter(t => typeof t === 'string'), '}']
-            .filter(a => a)
-            .join('\n'),
-    };
-};
-const addToSchema = gql `
-  directive @namedClient(name: String!) on OBJECT | FIELD
-`;
-const validate = async (schema, documents, config, outputFile) => {
-    if (extname(outputFile) !== '.cs') {
-        throw new Error(`Plugin "c-sharp-operations" requires extension to be ".cs"!`);
-    }
-};
-
-export { CSharpOperationsVisitor, addToSchema, plugin, validate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-codegen/c-sharp-operations",
-  "version": "2.2.13",
+  "version": "2.2.15-alpha-2cc8b095b.0",
   "description": "GraphQL Code Generator plugin for generating CSharp code based on GraphQL operations",
   "sideEffects": false,
   "peerDependencies": {
@@ -9,28 +9,36 @@
   },
   "dependencies": {
     "@graphql-codegen/plugin-helpers": "^2.4.0",
-    "@graphql-codegen/visitor-plugin-common": "2.9.1",
+    "@graphql-codegen/visitor-plugin-common": "^2.11.0-alpha-2cc8b095b.0",
+    "@graphql-codegen/c-sharp-common": "0.0.1-alpha-2cc8b095b.0",
     "auto-bind": "~4.0.0",
     "change-case-all": "1.0.14",
     "tslib": "~2.4.0"
   },
   "repository": "git@github.com:dotansimha/graphql-code-generator.git",
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
-    "./package.json": "./package.json",
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
+      "require": {
+        "types": "./typings/index.d.ts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
-    "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
-    }
+    "./package.json": "./package.json"
   }
-}
+}

package/{index.d.ts → typings/index.d.ts}

@@ -1,6 +1,6 @@
 import { PluginValidateFn, PluginFunction } from '@graphql-codegen/plugin-helpers';
-import { CSharpOperationsVisitor } from './visitor';
-import { CSharpOperationsRawPluginConfig } from './config';
+import { CSharpOperationsVisitor } from './visitor.js';
+import { CSharpOperationsRawPluginConfig } from './config.js';
 export declare const plugin: PluginFunction<CSharpOperationsRawPluginConfig>;
 export declare const addToSchema: import("graphql").DocumentNode;
 export declare const validate: PluginValidateFn<any>;

package/{visitor.d.ts → typings/visitor.d.ts}

@@ -1,8 +1,8 @@
 import { ClientSideBaseVisitor, ClientSideBasePluginConfig, LoadedFragment } from '@graphql-codegen/visitor-plugin-common';
 import { OperationDefinitionNode, GraphQLSchema, TypeNode, InputObjectTypeDefinitionNode, EnumTypeDefinitionNode } from 'graphql';
-import { CSharpOperationsRawPluginConfig } from './config';
+import { CSharpOperationsRawPluginConfig } from './config.js';
 import { Types } from '@graphql-codegen/plugin-helpers';
-import { CSharpFieldType } from '../../common/common';
+import { CSharpFieldType } from '@graphql-codegen/c-sharp-common';
 export interface CSharpOperationsPluginConfig extends ClientSideBasePluginConfig {
     namespaceName: string;
     namedClient: string;