@fraym/crud 0.1.0 → 0.3.0

package/README.md

@@ -8,6 +8,24 @@ Client implementation in javascript for the CRUD service [streams](https://githu
 npm i @fraym/crud
 ```
 
+## CLI command
+
+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 path 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
+{
+    "schemaGlob": "./src/crud/*.graphql", // path to your crud schema files
+    "serverAddress": "127.0.0.1:9000" // address of the crud service
+}
+```
+
 ## Usage
 
 ### Create the clients
@@ -17,7 +35,6 @@ delivery client:
 ```typescript
 const deliveryClient = await newDeliveryClient({
     serverAddress: "127.0.0.1:9000",
-    groupId: "your-services-group-identifier",
 });
 ```
 
@@ -26,7 +43,6 @@ management client:
 ```typescript
 const managementClient = await newManagementClient({
     serverAddress: "127.0.0.1:9000",
-    groupId: "your-services-group-identifier",
 });
 ```
 

package/dist/cmd/crud.d.ts

@@ -0,0 +1,2 @@
+#! /usr/bin/env node
+export {};

package/dist/cmd/crud.js

@@ -0,0 +1,218 @@
+#! /usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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 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({ 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 schemaGlob = argv.schemaGlob;
+    const serverAddress = argv.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 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);
+            }
+        });
+    });
+    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 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 (!definitions[existingName] || !definitions[existingName].isCrudType) {
+            typesToRemove.push(existingName);
+        }
+        else {
+            typesToUpdate.push(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(definitions).forEach(newName => {
+        if (!definitions[newName].isCrudType) {
+            return;
+        }
+        typesToCreate.push(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).catch(console.log);
+        console.log(`Removed ${typesToRemove.length} types`);
+    }
+    if (typesToUpdate.length > 0) {
+        console.log(`Updating ${typesToUpdate.length} types: ${typesToUpdate}...`);
+        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).catch(console.log);
+        console.log(`Created ${typesToCreate.length} types`);
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraym/crud",
-    "version": "0.1.0",
+    "version": "0.3.0",
     "license": "UNLICENSED",
     "homepage": "https://github.com/fraym/crud-nodejs",
     "repository": {
@@ -12,26 +12,37 @@
         "test": "echo \"Error: no test specified\" && exit 0",
         "format": "prettier --write \"**/*.{ts,tsx,json}\"",
         "lint": "prettier --check \"**/*.{ts,tsx,json}\"",
-        "build": "npm run clean && tsc",
+        "build": "npm run clean && tsc && chmod +x dist/cmd/crud.js",
         "clean": "rm -rf dist",
         "prepublishOnly": "npm test && npm run lint && npm run build",
-        "preversion": "npm run lint"
+        "preversion": "npm run lint",
+        "cmd": "dist/cmd/crud.js",
+        "cmd2": "dist/cmd/crud.js --config .tst/crud.config.json"
     },
     "files": [
         "dist/**/*"
     ],
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
+    "bin": {
+        "crud": "dist/cmd/crud.js"
+    },
     "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",
-        "uuid": "^9.0.0"
+        "fs": "^0.0.1-security",
+        "graphql": "^16.6.0",
+        "yargs": "^17.6.2"
     },
     "devDependencies": {
         "@becklyn/prettier": "^1.0.2",
         "@types/uuid": "^8.3.4",
+        "@types/yargs": "^17.0.13",
         "prettier": "^2.7.1",
-        "typescript": "^4.8.4"
+        "typescript": "^4.8.4",
+        "uuid": "^9.0.0"
     },
     "prettier": "@becklyn/prettier"
 }