@fraym/crud 0.2.0 → 0.3.0

package/README.md

@@ -12,15 +12,16 @@ npm i @fraym/crud
 
 Use the `crud` cli command to automatically apply your crud schemas to the crud service.
 
-The `--config ./path/crud.config.json` flag can be used to configure the pat to your config file.
+The `--config ./path/crud.config.json` flag can be used to configure the path of your config file.
 
-Your type schemas have to live directly below the path that you specified in `schemaPath` of your config file.
+Your type schemas have to match the glob you specify in `schemaGlob` of he config file (default: `./src/**/*.graphql`).
+You can specify the address (and port) of the crud service instance you use in `serverAddress` of the config file (default: `127.0.0.1:9000`).
 
 ### CLI command config
 
 ```json
 {
-    "schemaPath": "./src/crud", // path to your crud schema files
+    "schemaGlob": "./src/crud/*.graphql", // path to your crud schema files
     "serverAddress": "127.0.0.1:9000" // address of the crud service
 }
 ```

package/dist/cmd/crud.js

@@ -7,78 +7,212 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
 const yargs_1 = __importDefault(require("yargs/yargs"));
 const helpers_1 = require("yargs/helpers");
-const utilities_1 = require("graphql/utilities");
-const kinds_1 = require("graphql/language/kinds");
 const client_1 = require("../management/client");
+const load_1 = require("@graphql-tools/load");
+const graphql_file_loader_1 = require("@graphql-tools/graphql-file-loader");
+const graphql_1 = require("graphql");
 const run = async () => {
     const argv = await (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
-        .config({ schemaPath: "./src", serverAddress: "127.0.0.1:9000" })
+        .config({ schemaGlob: "./src/**/*.graphql", serverAddress: "127.0.0.1:9000" })
         .pkgConf("crud")
         .config("config", "Path of your `crud.config.ts`, default: `./crud.config.ts`", configPath => JSON.parse(fs_1.default.readFileSync(configPath, "utf-8"))).argv;
-    const schemaPath = argv.schemaPath;
+    const schemaGlob = argv.schemaGlob;
     const serverAddress = argv.serverAddress;
-    const schemas = getSchemas(schemaPath);
-    await migrateSchemas(schemas, serverAddress);
+    const schema = await (0, load_1.loadSchema)(`${schemaGlob}`, {
+        loaders: [new graphql_file_loader_1.GraphQLFileLoader()],
+    });
+    const definitions = getTypeDefinition(schema);
+    await migrateSchemas(definitions, serverAddress);
 };
 run();
-const getSchemas = (schemaPath) => {
-    const schemaFiles = fs_1.default.readdirSync(schemaPath);
-    const schemas = {};
-    schemaFiles.forEach(fileName => {
-        const astSchema = (0, utilities_1.buildSchema)(fs_1.default.readFileSync(schemaPath + "/" + fileName, "utf-8"));
-        astSchema.toConfig().types.forEach(t => {
-            var _a;
-            if (!((_a = t.astNode) === null || _a === void 0 ? void 0 : _a.kind)) {
-                return;
-            }
-            const name = t.toString();
-            const typeSchema = (0, utilities_1.buildASTSchema)({
-                definitions: [t.astNode],
-                kind: kinds_1.Kind.DOCUMENT,
-            });
-            if (schemas[name]) {
-                throw new Error(`duplicate schema for CRUD type "${name}" detected, try renaming one of them as they have to be unique`);
+const getTypeDefinition = (schema) => {
+    const definitions = {};
+    schema.toConfig().types.forEach(t => {
+        var _a;
+        if (((_a = t.astNode) === null || _a === void 0 ? void 0 : _a.kind) !== graphql_1.Kind.OBJECT_TYPE_DEFINITION || !(t instanceof graphql_1.GraphQLObjectType)) {
+            return;
+        }
+        const name = t.toString();
+        if (definitions[name]) {
+            throw new Error(`duplicate definition for type "${name}" detected, try renaming one of them as they have to be uniquely named`);
+        }
+        definitions[name] = getTypeDefinitionFromGraphQLObjectType(t);
+    });
+    return definitions;
+};
+const getTypeDefinitionFromGraphQLObjectType = (t) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const isCrudType = (_c = (((_a = t.astNode) === null || _a === void 0 ? void 0 : _a.directives) &&
+        ((_b = t.astNode) === null || _b === void 0 ? void 0 : _b.directives.length) > 0 &&
+        t.astNode.directives[0].name.value === "crudType")) !== null && _c !== void 0 ? _c : false;
+    const name = t.toString();
+    let objectDirectivesString = "";
+    let objectFieldsString = "";
+    let nestedTypes = [];
+    (_e = (_d = t.astNode) === null || _d === void 0 ? void 0 : _d.directives) === null || _e === void 0 ? void 0 : _e.forEach(d => {
+        objectDirectivesString += getDirectiveString(d);
+    });
+    (_g = (_f = t.astNode) === null || _f === void 0 ? void 0 : _f.fields) === null || _g === void 0 ? void 0 : _g.forEach(f => {
+        const { str, nestedTypes: newNestedTypes } = getFieldStringAndNestedTypes(f);
+        objectFieldsString += str;
+        newNestedTypes.forEach(nested => {
+            if (nestedTypes.indexOf(nested) === -1) {
+                nestedTypes.push(nested);
             }
-            schemas[name] = (0, utilities_1.printSchema)(typeSchema);
         });
     });
-    return schemas;
+    const schema = `type ${name}${objectDirectivesString} {${objectFieldsString}\n}`;
+    return {
+        isCrudType,
+        nestedTypes,
+        schema,
+    };
+};
+const getFieldStringAndNestedTypes = (f) => {
+    var _a;
+    let directivesString = "";
+    (_a = f.directives) === null || _a === void 0 ? void 0 : _a.forEach(d => {
+        directivesString += getDirectiveString(d);
+    });
+    const { nestedType, str: typeString } = getTypeData(f.type);
+    const nestedTypes = [];
+    if (nestedType) {
+        nestedTypes.push(nestedType);
+    }
+    return {
+        str: `\n${f.name.value}: ${typeString}${directivesString}`,
+        nestedTypes,
+    };
+};
+const getTypeData = (t) => {
+    switch (t.kind) {
+        case graphql_1.Kind.NAMED_TYPE:
+            const name = t.name.value;
+            return name === "String" ||
+                name === "Float" ||
+                name === "ID" ||
+                name === "Boolean" ||
+                name === "Int"
+                ? {
+                    str: name,
+                }
+                : {
+                    str: name,
+                    nestedType: name,
+                };
+        case graphql_1.Kind.LIST_TYPE:
+            const { nestedType: listNestedType, str: listStr } = getTypeData(t.type);
+            return {
+                str: `[${listStr}]`,
+                nestedType: listNestedType,
+            };
+        case graphql_1.Kind.NON_NULL_TYPE:
+            const { nestedType: nonNullNestedType, str: nonNullStr } = getTypeData(t.type);
+            return {
+                str: `${nonNullStr}!`,
+                nestedType: nonNullNestedType,
+            };
+    }
 };
-const migrateSchemas = async (schemas, serverAddress) => {
+const getDirectiveString = (d) => {
+    if (!d.arguments || d.arguments.length == 0) {
+        return ` @${d.name.value}`;
+    }
+    let argsString = "";
+    d.arguments.forEach(a => {
+        if (argsString !== "") {
+            argsString += ", ";
+        }
+        argsString += `${a.name.value}: ${getValueString(a.value)}`;
+    });
+    return ` @${d.name.value}(${argsString})`;
+};
+const getValueString = (v) => {
+    switch (v.kind) {
+        case graphql_1.Kind.LIST:
+            let valuesString = "";
+            v.values.forEach(el => {
+                if (valuesString !== "") {
+                    valuesString += ", ";
+                }
+                valuesString += getValueString(el);
+            });
+            return `[${valuesString}]`;
+        case graphql_1.Kind.STRING:
+            return `"${v.value}"`;
+        case graphql_1.Kind.FLOAT:
+        case graphql_1.Kind.INT:
+        case graphql_1.Kind.BOOLEAN:
+            return `${v.value}`;
+        case graphql_1.Kind.NULL:
+            return `null`;
+        case graphql_1.Kind.OBJECT:
+            let objectString = "";
+            v.fields.forEach(f => {
+                if (objectString !== "") {
+                    objectString += ", ";
+                }
+                objectString += `${f.name.value}: ${getValueString(f.value)}`;
+            });
+            return `{${objectString}}`;
+        default:
+            throw new Error(`values of kind ${v.kind} are currently not supported`);
+    }
+};
+const migrateSchemas = async (definitions, serverAddress) => {
     const managementClient = await (0, client_1.newManagementClient)({ serverAddress });
     const existingTypeNames = await managementClient.getAllTypes();
     let createSchema = "";
     let updateSchema = "";
     const typesToCreate = [];
+    const nestedTypesToCreate = [];
     const typesToUpdate = [];
+    const nestedTypesToUpdate = [];
     const typesToRemove = [];
     existingTypeNames.forEach(existingName => {
-        if (!schemas[existingName]) {
+        if (!definitions[existingName] || !definitions[existingName].isCrudType) {
             typesToRemove.push(existingName);
         }
         else {
             typesToUpdate.push(existingName);
-            updateSchema += `\n${schemas[existingName]}`;
-            delete schemas[existingName];
+            updateSchema += `\n${definitions[existingName].schema}`;
+            definitions[existingName].nestedTypes.forEach(nestedTypeName => {
+                if (nestedTypesToUpdate.indexOf(nestedTypeName) !== -1) {
+                    return;
+                }
+                updateSchema += `\n${definitions[nestedTypeName].schema}`;
+                nestedTypesToUpdate.push(nestedTypeName);
+            });
+            delete definitions[existingName];
         }
     });
-    Object.keys(schemas).forEach(newName => {
+    Object.keys(definitions).forEach(newName => {
+        if (!definitions[newName].isCrudType) {
+            return;
+        }
         typesToCreate.push(newName);
-        createSchema += `\n${schemas[newName]}`;
+        createSchema += `\n${definitions[newName].schema}`;
+        definitions[newName].nestedTypes.forEach(nestedTypeName => {
+            if (nestedTypesToCreate.indexOf(nestedTypeName) !== -1) {
+                return;
+            }
+            createSchema += `\n${definitions[nestedTypeName].schema}`;
+            nestedTypesToCreate.push(nestedTypeName);
+        });
     });
     if (typesToRemove.length > 0) {
         console.log(`Removing ${typesToRemove.length} types: ${typesToRemove}...`);
-        await managementClient.removeTypes(typesToRemove);
+        await managementClient.removeTypes(typesToRemove).catch(console.log);
         console.log(`Removed ${typesToRemove.length} types`);
     }
     if (typesToUpdate.length > 0) {
         console.log(`Updating ${typesToUpdate.length} types: ${typesToUpdate}...`);
-        await managementClient.updateTypes(updateSchema);
+        await managementClient.updateTypes(updateSchema).catch(console.log);
         console.log(`Updated ${typesToUpdate.length} types`);
     }
     if (typesToCreate.length > 0) {
         console.log(`Creating ${typesToCreate.length} types: ${typesToCreate}...`);
-        await managementClient.createTypes(createSchema);
+        await managementClient.createTypes(createSchema).catch(console.log);
         console.log(`Created ${typesToCreate.length} types`);
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraym/crud",
-    "version": "0.2.0",
+    "version": "0.3.0",
     "license": "UNLICENSED",
     "homepage": "https://github.com/fraym/crud-nodejs",
     "repository": {
@@ -29,6 +29,8 @@
     },
     "dependencies": {
         "@fraym/crud-proto": "^1.0.0-alpha.5",
+        "@graphql-tools/graphql-file-loader": "^7.5.11",
+        "@graphql-tools/load": "^7.8.6",
         "@grpc/grpc-js": "^1.7.2",
         "fs": "^0.0.1-security",
         "graphql": "^16.6.0",
@@ -39,8 +41,8 @@
         "@types/uuid": "^8.3.4",
         "@types/yargs": "^17.0.13",
         "prettier": "^2.7.1",
-        "uuid": "^9.0.0",
-        "typescript": "^4.8.4"
+        "typescript": "^4.8.4",
+        "uuid": "^9.0.0"
     },
     "prettier": "@becklyn/prettier"
 }