@ramathibodi/nuxt-commons 0.1.11 → 0.1.13

package/dist/runtime/composables/graphqlModelOperation.mjs

@@ -0,0 +1,77 @@
+import { computed } from "vue";
+import { graphqlOperation } from "#imports";
+export function useGraphqlModelOperation(props) {
+  function capitalizeFirstLetter(string) {
+    return string?.charAt(0).toUpperCase() + string?.slice(1);
+  }
+  function lowercaseFirstLetter(string) {
+    return string?.charAt(0).toLowerCase() + string?.slice(1);
+  }
+  const operationCreate = computed(() => {
+    if (props.operationCreate) {
+      if (typeof props.operationCreate === "string") {
+        if (graphqlOperation[props.operationCreate])
+          return graphqlOperation[props.operationCreate];
+      } else {
+        return props.operationCreate;
+      }
+    }
+    return graphqlOperation["create" + capitalizeFirstLetter(props.modelName)];
+  });
+  const operationUpdate = computed(() => {
+    if (props.operationUpdate) {
+      if (typeof props.operationUpdate === "string") {
+        if (graphqlOperation[props.operationUpdate])
+          return graphqlOperation[props.operationUpdate];
+      } else {
+        return props.operationUpdate;
+      }
+    }
+    return graphqlOperation["update" + capitalizeFirstLetter(props.modelName)];
+  });
+  const operationDelete = computed(() => {
+    if (props.operationDelete) {
+      if (typeof props.operationDelete === "string") {
+        if (graphqlOperation[props.operationDelete])
+          return graphqlOperation[props.operationDelete];
+      } else {
+        return props.operationDelete;
+      }
+    }
+    return graphqlOperation["delete" + capitalizeFirstLetter(props.modelName)];
+  });
+  const operationRead = computed(() => {
+    if (props.operationRead) {
+      if (typeof props.operationRead === "string") {
+        if (graphqlOperation[props.operationRead])
+          return graphqlOperation[props.operationRead];
+      } else {
+        return props.operationRead;
+      }
+    }
+    return graphqlOperation[lowercaseFirstLetter(props.modelName)];
+  });
+  const operationReadPageable = computed(() => {
+    if (props.operationReadPageable) {
+      if (typeof props.operationReadPageable === "string") {
+        if (graphqlOperation[props.operationReadPageable])
+          return graphqlOperation[props.operationReadPageable];
+      } else {
+        return props.operationReadPageable;
+      }
+    }
+    return graphqlOperation[lowercaseFirstLetter(props.modelName) + "Pageable"];
+  });
+  const operationSearch = computed(() => {
+    if (props.operationSearch) {
+      if (typeof props.operationSearch === "string") {
+        if (graphqlOperation[props.operationSearch])
+          return graphqlOperation[props.operationSearch];
+      } else {
+        return props.operationSearch;
+      }
+    }
+    return graphqlOperation["search" + capitalizeFirstLetter(props.modelName)];
+  });
+  return { operationCreate, operationUpdate, operationDelete, operationRead, operationReadPageable, operationSearch };
+}

package/dist/runtime/composables/graphqlOperation.d.ts

@@ -1,5 +1,5 @@
-import { type ClassConstructor } from "../utils/object";
-import type { graphqlTypeObject, graphqlVariable } from "../types/graphqlOperation";
+import { type ClassConstructor } from '../utils/object';
+import type { graphqlTypeObject, graphqlVariable } from '../types/graphqlOperation';
 export declare function buildFields(operationFields: graphqlTypeObject, fields?: Array<string | Object> | ClassConstructor<any>, depth?: number): Array<string | Object>;
 export declare function buildVariables(outputVariables?: graphqlVariable[], inputVariables?: {
     [p: string]: any;

package/dist/runtime/composables/graphqlOperation.mjs

@@ -1,6 +1,6 @@
-import { graphqlInputType, graphqlOperation, graphqlType, scalarType } from "#imports";
 import { classAttributes, isClassConstructor } from "../utils/object.mjs";
 import { useGraphQl } from "./graphql.mjs";
+import { graphqlInputType, graphqlOperation, graphqlType, scalarType } from "#imports";
 export function buildFields(operationFields, fields, depth = 0) {
   if (!operationFields)
     return [];
@@ -23,7 +23,7 @@ export function buildFields(operationFields, fields, depth = 0) {
     fields.push("userstampField");
   return fields.map((field) => {
     if (typeof field == "string" && !operationFields?.fields?.includes(field)) {
-      let relationField = operationFields?.relations?.find((relation) => relation.name == field);
+      const relationField = operationFields?.relations?.find((relation) => relation.name == field);
       if (relationField && relationField.type) {
         return { [relationField.name]: buildFields(graphqlType[relationField.type], void 0, depth - 1) };
       } else {
@@ -31,9 +31,9 @@ export function buildFields(operationFields, fields, depth = 0) {
       }
     } else if (typeof field == "object") {
       Object.keys(field).forEach((key) => {
-        let relationField = operationFields?.relations?.find((relation) => relation.name == key);
+        const relationField = operationFields?.relations?.find((relation) => relation.name == key);
         if (relationField && relationField.type) {
-          let castField = field;
+          const castField = field;
           castField[key] = buildFields(graphqlType[relationField.type], castField[key], depth - 1);
         }
       });
@@ -49,7 +49,7 @@ export function buildVariables(outputVariables, inputVariables, reject, isRoot =
       if (variable.type && !scalarType.includes(variable.type)) {
         if (variable.list) {
           if (inputVariables[variable.name] && Array.isArray(inputVariables[variable.name])) {
-            let tmpVariables = [];
+            const tmpVariables = [];
             inputVariables[variable.name].forEach((inputVariable) => {
               tmpVariables.push(buildVariables(graphqlInputType[variable.type].variables, inputVariable, reject, false));
             });
@@ -75,8 +75,8 @@ export function buildVariables(outputVariables, inputVariables, reject, isRoot =
       }
     }
   });
-  let usedVariables = outputVariables.map((variable) => variable.name);
-  let droppedVariable = Object.keys(inputVariables || {}).filter((key) => !usedVariables.includes(key));
+  const usedVariables = outputVariables.map((variable) => variable.name);
+  const droppedVariable = Object.keys(inputVariables || {}).filter((key) => !usedVariables.includes(key));
   if (droppedVariable.length > 0)
     console.debug("There is data not appeared in schema and dropped before operation.", droppedVariable);
   return outputVariables.reduce((acc, item) => {
@@ -85,9 +85,9 @@ export function buildVariables(outputVariables, inputVariables, reject, isRoot =
   }, {});
 }
 export function buildRequiredInputFields(variables, inputField = "input") {
-  let inputVariable = variables?.find((variable) => variable.name == inputField);
+  const inputVariable = variables?.find((variable) => variable.name == inputField);
   if (inputVariable) {
-    let returnFields = [];
+    const returnFields = [];
     graphqlInputType[inputVariable.type]?.variables?.forEach((variable) => {
       if (variable.required)
         returnFields.push(variable.name);

package/dist/runtime/types/formDialog.d.ts

@@ -1,4 +1,4 @@
 export interface FormDialogCallback {
-    done: Function
-    error: Function
-}
+  done: Function
+  error: Function
+}

package/dist/runtime/types/graphqlOperation.d.ts

@@ -1,23 +1,23 @@
 export interface graphqlVariable {
-    name: string;
-    list?: boolean;
-    required?: boolean;
-    type?: string;
-    value?: any;
+  name: string
+  list?: boolean
+  required?: boolean
+  type?: string
+  value?: any
 }
 export interface graphqlOperationObject<T, U> {
-    variables?: graphqlVariable[];
-    fields?: graphqlTypeObject;
-    operationType: "Query" | "Mutation";
-    name: string;
-    call: (fields?: Array<string | Object>, variables?: U) => Promise<T>;
+  variables?: graphqlVariable[]
+  fields?: graphqlTypeObject
+  operationType: 'Query' | 'Mutation'
+  name: string
+  call: (fields?: Array<string | Object>, variables?: U) => Promise<T>
 }
 
 export interface graphqlTypeObject {
-    fields: string[];
-    relations: graphqlVariable[];
+  fields: string[]
+  relations: graphqlVariable[]
 }
 
 export interface graphqlInputObject {
-    variables: graphqlVariable[];
-}
+  variables: graphqlVariable[]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ramathibodi/nuxt-commons",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Ramathibodi Nuxt modules for common components",
   "repository": {
     "type": "git",

package/scripts/postInstall.cjs

@@ -1,67 +1,70 @@
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
+const fs = require('node:fs')
+const path = require('node:path')
+const { execSync } = require('node:child_process')
 
 // Function to copy a file from source to destination
 function copyFile(src, dest) {
-    fs.mkdirSync(path.dirname(dest), { recursive: true });
-    fs.copyFileSync(src, dest);
-    console.log(`Copied ${src} to ${dest}`);
+  fs.mkdirSync(path.dirname(dest), { recursive: true })
+  fs.copyFileSync(src, dest)
+  console.log(`Copied ${src} to ${dest}`)
 }
 
 // Function to copy all files in a directory recursively
 function copyDirectory(srcDir, destDir) {
-    const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true })
 
-    for (let entry of entries) {
-        const srcPath = path.join(srcDir, entry.name);
-        const destPath = path.join(destDir, entry.name);
+  for (let entry of entries) {
+    const srcPath = path.join(srcDir, entry.name)
+    const destPath = path.join(destDir, entry.name)
 
-        if (entry.isDirectory()) {
-            copyDirectory(srcPath, destPath);
-        } else {
-            copyFile(srcPath, destPath);
-        }
+    if (entry.isDirectory()) {
+      copyDirectory(srcPath, destPath)
     }
+    else {
+      copyFile(srcPath, destPath)
+    }
+  }
 }
 
 // Function to modify package.json to add a new script
 function addScriptToPackageJson(scriptName, scriptCommand) {
-    const packageJsonPath = path.join(process.env.INIT_CWD, 'package.json');
-    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  const packageJsonPath = path.join(process.env.INIT_CWD, 'package.json')
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
 
-    packageJson.scripts = packageJson.scripts || {};
-    packageJson.scripts[scriptName] = scriptCommand;
+  packageJson.scripts = packageJson.scripts || {}
+  packageJson.scripts[scriptName] = scriptCommand
 
-    fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
-    console.log(`Added script "${scriptName}": "${scriptCommand}" to package.json`);
+  fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2))
+  console.log(`Added script "${scriptName}": "${scriptCommand}" to package.json`)
 }
 
 // Function to run npm run codegen safely
 function runCodegen(projectRoot) {
-    try {
-        execSync('npm run codegen', { cwd: projectRoot, stdio: 'inherit' });
-        console.log('Successfully ran npm run codegen');
-    } catch (error) {
-        console.log('npm run codegen failed or script not found, continuing...');
-    }
+  try {
+    execSync('npm run codegen', { cwd: projectRoot, stdio: 'inherit' })
+    console.log('Successfully ran npm run codegen')
+  }
+  catch (error) {
+    console.log('npm run codegen failed or script not found, continuing...')
+  }
 }
 
 if (process.env.INIT_CWD === process.cwd()) process.exit()
 
 // Define source and destination directories
-const srcDir = path.join(__dirname, '..', 'templates');
-const destDir = process.env.INIT_CWD; // Project root
+const srcDir = path.join(__dirname, '..', 'templates')
+const destDir = process.env.INIT_CWD // Project root
 
 // Copy all files from templates directory to project root
-copyDirectory(srcDir, destDir);
+copyDirectory(srcDir, destDir)
 
 // Add new script to package.json
-addScriptToPackageJson('codegen', 'graphql-codegen --require dotenv/config --config ./.codegen/codegen.ts dotenv_config_path=.env');
+addScriptToPackageJson('codegen', 'graphql-codegen --require dotenv/config --config ./.codegen/codegen.ts dotenv_config_path=.env')
 
 // Run npm run codegen safely
-if (!fs.existsSync(path.join(destDir, "types","graphql.ts")) || !fs.existsSync(path.join(destDir, "composables","graphqlObject.ts"))) {
-    if (process.env.NUXT_PUBLIC_WS_GRAPHQL) runCodegen(destDir);
-} else {
-    console.log('Skipping codegen');
+if (!fs.existsSync(path.join(destDir, 'types', 'graphql.ts')) || !fs.existsSync(path.join(destDir, 'composables', 'graphqlObject.ts'))) {
+  if (process.env.NUXT_PUBLIC_WS_GRAPHQL) runCodegen(destDir)
+}
+else {
+  console.log('Skipping codegen')
 }

package/templates/.codegen/codegen.ts

@@ -1,4 +1,4 @@
-import type {CodegenConfig} from '@graphql-codegen/cli';
+import type {CodegenConfig} from '@graphql-codegen/cli'
 
 const config: CodegenConfig = {
   overwrite: true,
@@ -8,8 +8,8 @@ const config: CodegenConfig = {
       plugins: [{
         add: {
           content: '//Auto-generated file, do not make any change. Content could be overwritten.',
-        }
-      },'typescript'],
+        },
+      }, 'typescript'],
       config: {
         maybeValue: 'T | null | undefined',
         inputMaybeValue: 'T | null | undefined',
@@ -22,11 +22,11 @@ const config: CodegenConfig = {
       plugins: [{
         add: {
           content: '//Auto-generated file, do not make any change. Content could be overwritten.',
-        }
-      },'./.codegen/plugin-schema-object.js'],
+        },
+      }, './.codegen/plugin-schema-object.js'],
     },
   },
-  hooks: { afterAllFileWrite: ['prettier --parser typescript --tab-width 4 --write'] }
-};
+  hooks: { afterAllFileWrite: ['prettier --parser typescript --tab-width 4 --write'] },
+}
 
-export default config;
+export default config

package/templates/.codegen/plugin-schema-object.js

@@ -3,146 +3,152 @@ const { visit } = require('graphql')
 const { camelCase } = require('lodash')
 
 function capitalizeFirstLetter(string) {
-    return string.charAt(0).toUpperCase() + string.slice(1);
+  return string.charAt(0).toUpperCase() + string.slice(1)
 }
 
-function inputTypeToObject(inputType,result) {
-    if (inputType.kind==="NonNullType") {
-        result["required"] = true
-        inputTypeToObject(inputType.type,result)
-    }
-    if (inputType.kind==="ListType") {
-        result["list"] = true
-        inputTypeToObject(inputType.type,result)
-    }
-    if (inputType.kind==="NamedType") {
-        result["type"] = inputType.name.value
-    }
+function inputTypeToObject(inputType, result) {
+  if (inputType.kind === 'NonNullType') {
+    result['required'] = true
+    inputTypeToObject(inputType.type, result)
+  }
+  if (inputType.kind === 'ListType') {
+    result['list'] = true
+    inputTypeToObject(inputType.type, result)
+  }
+  if (inputType.kind === 'NamedType') {
+    result['type'] = inputType.name.value
+  }
 }
 
 module.exports = {
-    plugin(schema, _documents, _config) {
-        const astNode = getCachedDocumentNodeFromSchema(schema) // Transforms the GraphQLSchema into ASTNode
+  plugin(schema, _documents, _config) {
+    const astNode = getCachedDocumentNodeFromSchema(schema) // Transforms the GraphQLSchema into ASTNode
 
-        const operationNode = []
-        const typeNode = []
-        const inputNode = []
+    const operationNode = []
+    const typeNode = []
+    const inputNode = []
 
-        const scalarType =['ID','String','Boolean','Int','Float']
+    const scalarType = ['ID', 'String', 'Boolean', 'Int', 'Float']
 
-        const result = visit(astNode, {
-            ObjectTypeDefinition(node) {
-                if (node.name.value==="Query" || node.name.value==="Mutation")
-                {
-                    node.fields.forEach((field)=>{
-                        let fieldType = {}
-                        let fieldVariables = []
-                        inputTypeToObject(field.type,fieldType)
-                        field.arguments.forEach((argument)=>{
-                            let fieldVariablesItem = {name: argument.name.value}
-                            if (argument.defaultValue) fieldVariablesItem.value = argument.defaultValue.value
-                            if (argument.type) inputTypeToObject(argument.type,fieldVariablesItem)
-                            fieldVariables.push(fieldVariablesItem)
-                        })
-                        operationNode.push({
-                            name: field.name.value,
-                            variables: fieldVariables,
-                            type: fieldType.type,
-                            operationType: node.name.value
-                        })
-                    })
-                } else {
-                    let fields = []
-                    node.fields.forEach((field)=>{
-                        let fieldVariablesItem = {name: field.name.value}
-                        if (field.type) inputTypeToObject(field.type,fieldVariablesItem)
-                        fields.push(fieldVariablesItem)
-                    })
-                    typeNode.push({
-                        name: node.name.value,
-                        fields: fields
-                    })
-                }
-            },
-            InputObjectTypeDefinition(node) {
-                let fields = []
-                node.fields.forEach((field)=>{
-                    let fieldVariablesItem = {name: field.name.value}
-                    if (field.defaultValue) fieldVariablesItem.value = field.defaultValue.value
-                    if (field.type) inputTypeToObject(field.type,fieldVariablesItem)
-                    fields.push(fieldVariablesItem)
-                })
-                inputNode.push({
-                    name: node.name.value,
-                    variables: fields,
-                })
-            },
-            ScalarTypeDefinition(node) {
-                scalarType.push(node.name.value)
-            }
-        })
-
-        typeNode.map((node)=>{
-            let scalars = []
-            let relations = []
-            node.fields.forEach((field)=>{
-                if (scalarType.includes(field.type)) scalars.push(field.name)
-                else relations.push(field)
+    const result = visit(astNode, {
+      ObjectTypeDefinition(node) {
+        if (node.name.value === 'Query' || node.name.value === 'Mutation') {
+          node.fields.forEach((field) => {
+            let fieldType = {}
+            let fieldVariables = []
+            inputTypeToObject(field.type, fieldType)
+            field.arguments.forEach((argument) => {
+              let fieldVariablesItem = { name: argument.name.value }
+              if (argument.defaultValue) fieldVariablesItem.value = argument.defaultValue.value
+              if (argument.type) inputTypeToObject(argument.type, fieldVariablesItem)
+              fieldVariables.push(fieldVariablesItem)
+            })
+            operationNode.push({
+              name: field.name.value,
+              variables: fieldVariables,
+              type: fieldType.type,
+              operationType: node.name.value,
             })
-            node.scalars = scalars
-            node.relations = relations
+          })
+        }
+        else {
+          let fields = []
+          node.fields.forEach((field) => {
+            let fieldVariablesItem = { name: field.name.value }
+            if (field.type) inputTypeToObject(field.type, fieldVariablesItem)
+            fields.push(fieldVariablesItem)
+          })
+          typeNode.push({
+            name: node.name.value,
+            fields: fields,
+          })
+        }
+      },
+      InputObjectTypeDefinition(node) {
+        let fields = []
+        node.fields.forEach((field) => {
+          let fieldVariablesItem = { name: field.name.value }
+          if (field.defaultValue) fieldVariablesItem.value = field.defaultValue.value
+          if (field.type) inputTypeToObject(field.type, fieldVariablesItem)
+          fields.push(fieldVariablesItem)
+        })
+        inputNode.push({
+          name: node.name.value,
+          variables: fields,
         })
+      },
+      ScalarTypeDefinition(node) {
+        scalarType.push(node.name.value)
+      },
+    })
 
-        return `
+    typeNode.map((node) => {
+      let scalars = []
+      let relations = []
+      node.fields.forEach((field) => {
+        if (scalarType.includes(field.type)) scalars.push(field.name)
+        else relations.push(field)
+      })
+      node.scalars = scalars
+      node.relations = relations
+    })
+
+    return `
         import * as graphQlClass from "~/types/graphql"
         import { useGraphQlOperation } from "#imports";
+        import type {
+            graphqlInputObject,
+            graphqlOperationObject,
+            graphqlTypeObject,
+            graphqlVariable
+          } from "#build/types/graphqlOperation";
         
         export const scalarType = ${JSON.stringify(scalarType)}
         
-        function operationCall${"<"+"T,U>"}(operationType:string, operation: string,fields?: ${"Array"+"<string | Object>"},variables?: U) {
-            return useGraphQlOperation${"<"+"T>"}(operationType,operation,fields,variables as {[p: string] : any} | undefined)
+        function operationCall${'<' + 'T,U>'}(operationType:string, operation: string,fields?: ${'Array' + '<string | Object>'},variables?: U) {
+            return useGraphQlOperation${'<' + 'T>'}(operationType,operation,fields,variables as {[p: string] : any} | undefined)
         }
         
-        function createGraphQLOperation${"<"+"T,U>"}(operationType: "Query" | "Mutation",name: string,variables?: graphqlVariable[],fields?: graphqlTypeObject): graphqlOperationObject${"<"+"T,U>"} {
+        function createGraphQLOperation${'<' + 'T,U>'}(operationType: "Query" | "Mutation",name: string,variables?: graphqlVariable[],fields?: graphqlTypeObject): graphqlOperationObject${'<' + 'T,U>'} {
             return {
                 operationType,
                 name,
                 variables,
                 fields,
-                call: async function(fields?: ${"Array"+"<string | Object>"}, variables?: U): Promise${"<"+"T>"} {
+                call: async function(fields?: ${'Array' + '<string | Object>'}, variables?: U): Promise${'<' + 'T>'} {
                     return operationCall(operationType,name, fields, variables);
                 }
             }
         }
         
-        interface graphqlTypeObjects extends ${"Record<string,"+"graphqlTypeObject>"} {
-        ${typeNode.map((node)=>`${node.name}:  graphqlTypeObject`).join("\n")}
+        interface graphqlTypeObjects extends ${'Record<string,' + 'graphqlTypeObject>'} {
+        ${typeNode.map(node => `${node.name}:  graphqlTypeObject`).join('\n')}
         }
         
         export const graphqlType: graphqlTypeObjects= {
-        ${typeNode.map((node)=>`${node.name} : {
+        ${typeNode.map(node => `${node.name} : {
         fields : ${JSON.stringify(node.scalars)},
         relations: ${JSON.stringify(node.relations)}
-        } as graphqlTypeObject `).join(",")}
+        } as graphqlTypeObject `).join(',')}
         }
         
-        interface graphqlInputObjects extends ${"Record<string,"+"graphqlInputObject>"} {
-        ${inputNode.map((node)=>`${node.name}:  graphqlInputObject`).join("\n")}
+        interface graphqlInputObjects extends ${'Record<string,' + 'graphqlInputObject>'} {
+        ${inputNode.map(node => `${node.name}:  graphqlInputObject`).join('\n')}
         }
         
         export const graphqlInputType: graphqlInputObjects = {
-        ${inputNode.map((node)=>`${node.name} : {
+        ${inputNode.map(node => `${node.name} : {
         variables: ${JSON.stringify(node.variables)},
-        }`).join(",")}
+        }`).join(',')}
         }
         
-        interface graphqlOperationObjects extends ${"Record<string,"+"graphqlOperationObject"+"<"+"any"+",any>"+">"} {
-        ${operationNode.map((node)=>`${node.name}:  graphqlOperationObject${"<graphQlClass"+"."+node.operationType+"['"+node.name+"'],"+ ((node.variables.length) ? "graphQlClass."+node.operationType+capitalizeFirstLetter(camelCase(node.name))+"Args" : "undefined")+">"}`).join("\n")}
+        interface graphqlOperationObjects extends ${'Record<string,' + 'graphqlOperationObject' + '<' + 'any' + ',any>' + '>'} {
+        ${operationNode.map(node => `${node.name}:  graphqlOperationObject${'<graphQlClass' + '.' + node.operationType + '[\'' + node.name + '\'],' + ((node.variables.length) ? 'graphQlClass.' + node.operationType + capitalizeFirstLetter(camelCase(node.name)) + 'Args' : 'undefined') + '>'}`).join('\n')}
         }
         
         export const graphqlOperation: graphqlOperationObjects = {
-        ${operationNode.map((node)=>`${node.name}:  createGraphQLOperation${"<graphQlClass"+"."+node.operationType+"['"+node.name+"'],"+ ((node.variables.length) ? "graphQlClass."+node.operationType+capitalizeFirstLetter(camelCase(node.name))+"Args" : "undefined")+">"}('${node.operationType}','${node.name}',${JSON.stringify(node.variables)},${typeNode.find((type)=>type.name===node.type) ? "graphqlType."+node.type : "undefined"})`).join(",")}
+        ${operationNode.map(node => `${node.name}:  createGraphQLOperation${'<graphQlClass' + '.' + node.operationType + '[\'' + node.name + '\'],' + ((node.variables.length) ? 'graphQlClass.' + node.operationType + capitalizeFirstLetter(camelCase(node.name)) + 'Args' : 'undefined') + '>'}('${node.operationType}','${node.name}',${JSON.stringify(node.variables)},${typeNode.find(type => type.name === node.type) ? 'graphqlType.' + node.type : 'undefined'})`).join(',')}
         }
         `
-    }
-}
+  },
+}