@vladimirdev635/gql-codegen 0.0.96 → 0.0.98

package/schema/utils.js

@@ -1,6 +1,6 @@
 /* eslint-disable max-lines */
 import { readFileSync } from 'fs';
-import { serverSchema } from './server.js';
+import { serverSchema, } from './server.js';
 import { clientSchema } from './client/root.js';
 import { exec } from 'node:child_process';
 export function loadSchemaFromFile(p, schema) {
@@ -18,12 +18,10 @@ export async function loadServerSchemaFromGQLSubprocess(gqlPath = 'gql', gqlArgs
             if (err !== null) {
                 reject(err);
             }
-            ;
             if (stderr !== '') {
                 reject(err);
             }
-            ;
-            resolve(stdout.split('\n').filter(s => s !== '')[0]);
+            resolve(stdout.split('\n').filter((s) => s !== '')[0]);
         });
     });
     return serverSchema.parse(JSON.parse(output));
@@ -34,12 +32,10 @@ export async function loadRootSchemaFromGQLSubprocess(gqlPath = 'gql', gqlArgs =
             if (err !== null) {
                 reject(err);
             }
-            ;
             if (stderr !== '') {
                 reject(err);
             }
-            ;
-            resolve(stdout.split('\n').filter(s => s !== ''));
+            resolve(stdout.split('\n').filter((s) => s !== ''));
         });
     });
     return {
@@ -60,11 +56,11 @@ function buildFragmentSpecFromUnion(union) {
                     _type: 'ObjectFragmentSpec',
                     name: item,
                     selections: [
-                        { _type: 'SpreadSelection', fragment: item }
-                    ]
-                }
-            }))
-        ]
+                        { _type: 'SpreadSelection', fragment: item },
+                    ],
+                },
+            })),
+        ],
     };
 }
 function generateFragmentText(name, specText) {
@@ -75,35 +71,38 @@ export function buildFragmentFromUnion(union) {
         spec: buildFragmentSpecFromUnion(union),
         sourceText: generateFragmentText(union.name, 
         // eslint-disable-next-line no-use-before-define
-        generateUnionFragmentSpecText(union))
+        generateUnionFragmentSpecText(union)),
     };
 }
-;
 function extractFieldFromObjectLiteralFieldSpec(spec) {
     switch (spec.type._type) {
-        case 'Enum': return '';
-        case 'Scalar': return '';
+        case 'Enum':
+            return '';
+        case 'Scalar':
+            return '';
         case 'Union':
         case 'ObjectType':
         case 'InterfaceType':
             return '{...' + spec.type.name + '}';
     }
-    ;
 }
-;
 function extractFieldFromNonCallableFieldSpec(spec) {
     switch (spec._type) {
-        case 'literal': return extractFieldFromObjectLiteralFieldSpec(spec);
-        case 'array': return extractFieldFromNonCallableFieldSpec(spec.type);
+        case 'literal':
+            return extractFieldFromObjectLiteralFieldSpec(spec);
+        case 'array':
+            return extractFieldFromNonCallableFieldSpec(spec.type);
     }
 }
-;
 function buildInputFieldSpec(spec) {
     switch (spec._type) {
-        case 'literal': return spec.type.name;
+        case 'literal':
+            return spec.type.name;
         case 'array':
-            return '[' + buildInputFieldSpec(spec.type) +
-                (spec.nullable ? '' : '!') + ']';
+            return ('[' +
+                buildInputFieldSpec(spec.type) +
+                (spec.nullable ? '' : '!') +
+                ']');
     }
 }
 function buildInputField(field) {
@@ -111,13 +110,12 @@ function buildInputField(field) {
     if (!field.nullable) {
         str += '!';
     }
-    ;
     return str;
 }
-;
 function extractTypeFromObjectFieldSpec(spec) {
     switch (spec._type) {
-        case 'literal': return spec.type;
+        case 'literal':
+            return spec.type;
         case 'array':
             return extractTypeFromObjectFieldSpec(spec.type);
         case 'callable':
@@ -125,7 +123,8 @@ function extractTypeFromObjectFieldSpec(spec) {
     }
 }
 function generateObjectFragmentSpecText(object, onlyField = null) {
-    return '{' + (onlyField !== null ? '' : '__typename ') +
+    return ('{' +
+        (onlyField !== null ? '' : '__typename ') +
         Object.entries(object.fields)
             .filter(([name]) => onlyField === null || onlyField === name)
             // eslint-disable-next-line array-callback-return
@@ -140,58 +139,65 @@ function generateObjectFragmentSpecText(object, onlyField = null) {
                     const fieldText = extractFieldFromNonCallableFieldSpec(field.spec.returnType);
                     return [
                         `${name}(` +
-                            Object.keys(field.spec.arguments).map(aName => `${aName}:$${aName}`).join(',') +
+                            Object.keys(field.spec.arguments)
+                                .map((aName) => `${aName}:$${aName}`)
+                                .join(',') +
                             ')',
-                        fieldText
+                        fieldText,
                     ].join('');
                 }
+                default:
+                    throw new Error('Unreachable');
             }
-            ;
-        }).join(' ') +
-        '}';
+        })
+            .join(' ') +
+        '}');
 }
 function generateUnionFragmentSpecText(union) {
     return ('{__typename' +
-        Object.keys(union.items).map(item => `... on ${item}{...${item}}`).join(' ') +
+        Object.keys(union.items)
+            .map((item) => `... on ${item}{...${item}}`)
+            .join(' ') +
         '}');
 }
 export function buildSelectionFromFieldSpec(spec) {
     const type = extractTypeFromObjectFieldSpec(spec);
     switch (type._type) {
         case 'Enum':
-        case 'Scalar': return null;
+        case 'Scalar':
+            return null;
         case 'ObjectType':
         case 'InterfaceType':
             return {
                 _type: 'ObjectFragmentSpec',
                 name: type.name,
-                selections: [
-                    { _type: 'SpreadSelection', fragment: type.name }
-                ]
+                selections: [{ _type: 'SpreadSelection', fragment: type.name }],
             };
         case 'Union':
             return {
                 _type: 'UnionFragmentSpec',
                 name: type.name,
-                selections: [
-                    { _type: 'SpreadSelection', fragment: type.name }
-                ]
+                selections: [{ _type: 'SpreadSelection', fragment: type.name }],
             };
     }
 }
 export function buildArgumentFromFieldSpec(spec) {
     switch (spec._type) {
         case 'array':
-        case 'literal': return {};
+        case 'literal':
+            return {};
         case 'callable':
-            return Object.fromEntries(Object.keys(spec.arguments).map(name => {
-                return [name, {
+            return Object.fromEntries(Object.keys(spec.arguments).map((name) => {
+                return [
+                    name,
+                    {
                         name,
                         value: {
                             _type: 'ref',
-                            name: '$' + name
-                        }
-                    }];
+                            name: '$' + name,
+                        },
+                    },
+                ];
             }));
     }
 }
@@ -201,27 +207,25 @@ export function buildFieldSelection(name, field) {
         name,
         alias: name,
         arguments: buildArgumentFromFieldSpec(field.spec),
-        selection: buildSelectionFromFieldSpec(field.spec)
+        selection: buildSelectionFromFieldSpec(field.spec),
     };
 }
-;
 function buildFragmentSpecFromObject(object) {
     return {
         _type: 'ObjectFragmentSpec',
         name: object.name,
         selections: [
             { _type: 'TypenameField', alias: null },
-            ...Object.entries(object.fields).map(([name, field]) => buildFieldSelection(name, field))
-        ]
+            ...Object.entries(object.fields).map(([name, field]) => buildFieldSelection(name, field)),
+        ],
     };
 }
 export function buildFragmentFromObject(object) {
     return {
         spec: buildFragmentSpecFromObject(object),
-        sourceText: generateFragmentText(object.name, generateObjectFragmentSpecText(object))
+        sourceText: generateFragmentText(object.name, generateObjectFragmentSpecText(object)),
     };
 }
-;
 function buildParameters(field) {
     const parameters = {};
     if (field._type === 'callable') {
@@ -235,13 +239,18 @@ function buildOperationSourceText(opType, object, name, fieldName, spec) {
     let argumentsText = '';
     if (spec._type === 'callable') {
         argumentsText += '(';
-        argumentsText += Object.entries(spec.arguments).map(([aName, arg]) => {
+        argumentsText += Object.entries(spec.arguments)
+            .map(([aName, arg]) => {
             return `$${aName}:${buildInputField(arg)}`;
-        }).join(',');
+        })
+            .join(',');
         argumentsText += ')';
     }
-    return opType.toLowerCase() + ' ' + name + argumentsText +
-        generateObjectFragmentSpecText(object, fieldName);
+    return (opType.toLowerCase() +
+        ' ' +
+        name +
+        argumentsText +
+        generateObjectFragmentSpecText(object, fieldName));
 }
 function buildFragmentSpecFromField(opType, name, field) {
     return {
@@ -253,9 +262,9 @@ function buildFragmentSpecFromField(opType, name, field) {
                 name,
                 alias: name,
                 arguments: buildArgumentFromFieldSpec(field.spec),
-                selection: buildSelectionFromFieldSpec(field.spec)
-            }
-        ]
+                selection: buildSelectionFromFieldSpec(field.spec),
+            },
+        ],
     };
 }
 function buildOperation(type, object, fieldName, field) {
@@ -293,18 +302,20 @@ function buildOperations(server) {
 export function buildClientSchemaFromServerSchema(server) {
     return {
         fragments: Object.fromEntries([
-            ...Object.values(server.unions)
-                .map(union => [
+            ...Object.values(server.unions).map((union) => [
                 union.name,
-                buildFragmentFromUnion(union)
+                buildFragmentFromUnion(union),
             ]),
             ...Object.values(server.objects)
-                .filter(object => object.name !== 'Query' &&
+                .filter((object) => object.name !== 'Query' &&
                 object.name !== 'Mutation' &&
-                object.name !== 'Subscription').map(object => [object.name, buildFragmentFromObject(object)]),
+                object.name !== 'Subscription')
+                .map((object) => [
+                object.name,
+                buildFragmentFromObject(object),
+            ]),
         ]),
         operations: buildOperations(server),
-        directives: {}
+        directives: {},
     };
 }
-;

package/utils.js

@@ -7,8 +7,7 @@ export function entries(obj) {
 export function fromEntries(eList) {
     return Object.fromEntries(eList);
 }
-;
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export function assertUnreachable(_) {
-    throw new Error('Didn\'t expect to get here');
+    throw new Error("Didn't expect to get here");
 }