@ramathibodi/nuxt-commons 0.1.73 → 0.1.75

package/scripts/postInstall.cjs

@@ -1,70 +1,70 @@
-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}`)
-}
-
-// Function to copy all files in a directory recursively
-function copyDirectory(srcDir, destDir) {
-  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)
-
-    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'))
-
-  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`)
-}
-
-// 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...')
-  }
-}
-
-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
-
-// Copy all files from templates directory to project root
-copyDirectory(srcDir, destDir)
-
-// Add new script to package.json
-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')
-}
+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}`)
+}
+
+// Function to copy all files in a directory recursively
+function copyDirectory(srcDir, destDir) {
+  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)
+
+    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'))
+
+  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`)
+}
+
+// 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...')
+  }
+}
+
+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
+
+// Copy all files from templates directory to project root
+copyDirectory(srcDir, destDir)
+
+// Add new script to package.json
+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')
+}

package/templates/.codegen/codegen.ts

@@ -1,32 +1,32 @@
-import type {CodegenConfig} from '@graphql-codegen/cli'
-
-const config: CodegenConfig = {
-  overwrite: true,
-  schema: process.env.NUXT_PUBLIC_WS_GRAPHQL,
-  generates: {
-    './types/graphql.ts': {
-      plugins: [{
-        add: {
-          content: '//Auto-generated file, do not make any change. Content could be overwritten.',
-        },
-      }, 'typescript'],
-      config: {
-        maybeValue: 'T | null | undefined',
-        inputMaybeValue: 'T | null | undefined',
-        declarationKind: 'class',
-        enumsAsTypes: true,
-        skipTypename: true,
-      },
-    },
-    './composables/graphqlObject.ts': {
-      plugins: [{
-        add: {
-          content: '//Auto-generated file, do not make any change. Content could be overwritten.',
-        },
-      }, './.codegen/plugin-schema-object.js'],
-    },
-  },
-  hooks: { afterAllFileWrite: ['prettier --parser typescript --tab-width 4 --write'] },
-}
-
-export default config
+import type {CodegenConfig} from '@graphql-codegen/cli'
+
+const config: CodegenConfig = {
+  overwrite: true,
+  schema: process.env.NUXT_PUBLIC_WS_GRAPHQL,
+  generates: {
+    './types/graphql.ts': {
+      plugins: [{
+        add: {
+          content: '//Auto-generated file, do not make any change. Content could be overwritten.',
+        },
+      }, 'typescript'],
+      config: {
+        maybeValue: 'T | null | undefined',
+        inputMaybeValue: 'T | null | undefined',
+        declarationKind: 'class',
+        enumsAsTypes: true,
+        skipTypename: true,
+      },
+    },
+    './composables/graphqlObject.ts': {
+      plugins: [{
+        add: {
+          content: '//Auto-generated file, do not make any change. Content could be overwritten.',
+        },
+      }, './.codegen/plugin-schema-object.js'],
+    },
+  },
+  hooks: { afterAllFileWrite: ['prettier --parser typescript --tab-width 4 --write'] },
+}
+
+export default config

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

@@ -1,161 +1,161 @@
-const { getCachedDocumentNodeFromSchema } = require('@graphql-codegen/plugin-helpers')
-const { visit } = require('graphql')
-const { camelCase } = require('lodash')
-
-function capitalizeFirstLetter(string) {
-  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
-  }
-}
-
-module.exports = {
-  plugin(schema, _documents, _config) {
-    const astNode = getCachedDocumentNodeFromSchema(schema) // Transforms the GraphQLSchema into ASTNode
-
-    const operationNode = []
-    const typeNode = []
-    const inputNode = []
-
-    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)
-      })
-      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,cache: boolean | number = false) {
-            return useGraphQlOperation${'<' + 'T>'}(operationType,operation,fields,variables as {[p: string] : any} | undefined,cache)
-        }
-        
-        function createGraphQLOperation${'<' + 'T,U>'}(operationType: "Query" | "Mutation",name: string,variables?: graphqlVariable[],fields?: graphqlTypeObject): graphqlOperationObject${'<' + 'T,U>'} {
-            let returnGraphqlOperation : ${'Record' + '<string,any>'} = {
-                operationType,
-                name,
-                variables,
-                fields,
-            }
-            if (operationType === "Mutation") {
-              returnGraphqlOperation['call'] = async function(fields?: ${'Array' + '<string | Object>'}, variables?: U): Promise${'<' + 'T>'} {
-                  return operationCall(operationType,name, fields, variables);
-              }
-            } else {
-              returnGraphqlOperation['call'] = async function(fields?: ${'Array' + '<string | Object>'}, variables?: U,cache: boolean | number = false): Promise${'<' + 'T>'} {
-                  return operationCall(operationType,name, fields, variables,cache);
-              }
-            }
-            return returnGraphqlOperation as graphqlOperationObject${'<' + 'T,U>'}
-        }
-        
-        interface graphqlTypeObjects extends ${'Record<string,' + 'graphqlTypeObject>'} {
-        ${typeNode.map(node => `${node.name}:  graphqlTypeObject`).join('\n')}
-        }
-        
-        export const graphqlType: graphqlTypeObjects= {
-        ${typeNode.map(node => `${node.name} : {
-        fields : ${JSON.stringify(node.scalars)},
-        relations: ${JSON.stringify(node.relations)}
-        } as graphqlTypeObject `).join(',')}
-        }
-        
-        interface graphqlInputObjects extends ${'Record<string,' + 'graphqlInputObject>'} {
-        ${inputNode.map(node => `${node.name}:  graphqlInputObject`).join('\n')}
-        }
-        
-        export const graphqlInputType: graphqlInputObjects = {
-        ${inputNode.map(node => `${node.name} : {
-        variables: ${JSON.stringify(node.variables)},
-        }`).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')}
-        }
-        
-        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(',')}
-        }
-        `
-  },
-}
+const { getCachedDocumentNodeFromSchema } = require('@graphql-codegen/plugin-helpers')
+const { visit } = require('graphql')
+const { camelCase } = require('lodash')
+
+function capitalizeFirstLetter(string) {
+  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
+  }
+}
+
+module.exports = {
+  plugin(schema, _documents, _config) {
+    const astNode = getCachedDocumentNodeFromSchema(schema) // Transforms the GraphQLSchema into ASTNode
+
+    const operationNode = []
+    const typeNode = []
+    const inputNode = []
+
+    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)
+      })
+      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,cache: boolean | number = false) {
+            return useGraphQlOperation${'<' + 'T>'}(operationType,operation,fields,variables as {[p: string] : any} | undefined,cache)
+        }
+        
+        function createGraphQLOperation${'<' + 'T,U>'}(operationType: "Query" | "Mutation",name: string,variables?: graphqlVariable[],fields?: graphqlTypeObject): graphqlOperationObject${'<' + 'T,U>'} {
+            let returnGraphqlOperation : ${'Record' + '<string,any>'} = {
+                operationType,
+                name,
+                variables,
+                fields,
+            }
+            if (operationType === "Mutation") {
+              returnGraphqlOperation['call'] = async function(fields?: ${'Array' + '<string | Object>'}, variables?: U): Promise${'<' + 'T>'} {
+                  return operationCall(operationType,name, fields, variables);
+              }
+            } else {
+              returnGraphqlOperation['call'] = async function(fields?: ${'Array' + '<string | Object>'}, variables?: U,cache: boolean | number = false): Promise${'<' + 'T>'} {
+                  return operationCall(operationType,name, fields, variables,cache);
+              }
+            }
+            return returnGraphqlOperation as graphqlOperationObject${'<' + 'T,U>'}
+        }
+        
+        interface graphqlTypeObjects extends ${'Record<string,' + 'graphqlTypeObject>'} {
+        ${typeNode.map(node => `${node.name}:  graphqlTypeObject`).join('\n')}
+        }
+        
+        export const graphqlType: graphqlTypeObjects= {
+        ${typeNode.map(node => `${node.name} : {
+        fields : ${JSON.stringify(node.scalars)},
+        relations: ${JSON.stringify(node.relations)}
+        } as graphqlTypeObject `).join(',')}
+        }
+        
+        interface graphqlInputObjects extends ${'Record<string,' + 'graphqlInputObject>'} {
+        ${inputNode.map(node => `${node.name}:  graphqlInputObject`).join('\n')}
+        }
+        
+        export const graphqlInputType: graphqlInputObjects = {
+        ${inputNode.map(node => `${node.name} : {
+        variables: ${JSON.stringify(node.variables)},
+        }`).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')}
+        }
+        
+        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(',')}
+        }
+        `
+  },
+}