@fraym/projections 0.1.0

package/README.md

@@ -0,0 +1,156 @@
+# projections-nodejs
+
+Client implementation in javascript for the projections service [streams](https://github.com/fraym/projections).
+
+## Installation
+
+```shell
+npm i @fraym/projections
+```
+
+## GraphQL
+
+You can access the graphQL api at `http://projections:3000/delivery/graphql`.
+There is a sandbox available at `http://projections:3000/delivery/graphql/sandbox`.
+
+You need to add the `Tenant-Id` header in order to use the graphQL Endpoint and the sandbox.
+
+## CLI command
+
+Use the `projections` cli command to automatically apply your projection schemas to the projections service.
+
+Your type schemas have to match the glob you specify in the `PROJECTIONS_SCHEMA_GLOB` env variable (default: `./src/**/*.graphql`).
+You can specify the address (and port) of the crud service instance you use in the `PROJECTIONS_SERVER_ADDRESS` env variable (default: `127.0.0.1:9000`).
+
+You need to add a file that contains all built-in directives to your type schemas. The latest version of this file can be found [here](default.graphql).
+
+### Config
+
+Use a `.env` file or env variables to configure cte clients and the command:
+
+```env
+PROJECTIONS_SERVER_ADDRESS=127.0.0.1:9000
+PROJECTIONS_SCHEMA_GLOB=./src/projections/*.graphql
+```
+
+## Usage
+
+### Create the clients
+
+delivery client:
+
+```typescript
+const deliveryClient = await newDeliveryClient();
+```
+
+management client:
+
+```typescript
+const managementClient = await newManagementClient();
+```
+
+### Create one or multipe projections
+
+Projectionw are defined by schemas. A schema can contain more than one projection definition. See [SCHEMA.md](https://github.com/fraym/projections/blob/develop/SCHEMA.md) for a reference.
+
+```typescript
+await managementClient.create("your schema here");
+```
+
+### Update one or multipe projections
+
+Projectionw are defined by schemas. A schema can contain more than one projection definition. See [SCHEMA.md](https://github.com/fraym/projections/blob/develop/SCHEMA.md) for a reference.
+
+```typescript
+await managementClient.update("your schema here");
+```
+
+### Remove one or multipe projections
+
+The name of `YourProjection` has to equal your projection name in your schema (also in casing).
+
+```typescript
+await managementClient.remove(["YourProjection"]);
+```
+
+### Get list of existing projections
+
+```typescript
+const list = await managementClient.getAll();
+```
+
+### Get a single projection element
+
+The name of `YourProjection` has to equal your projection name in your schema (also in casing).
+The `id` has to match the id of the projection element that you want to get.
+
+```typescript
+const data = await deliveryClient.getData("tenantId", "YourProjection", "id");
+```
+
+You can specify a fourth parameter if you want to return a empty dataset instead of getting an error when querying a non existing element:
+
+```typescript
+const data = await deliveryClient.getData("tenantId", "YourProjection", "id", true);
+```
+
+### Get (paginated) data
+
+The name of `YourProjection` has to equal your type name in your schema (also in casing).
+
+No pagination:
+
+```typescript
+const data = await deliveryClient.getDataList("tenantId", "YourProjection");
+```
+
+With pagination:
+
+```typescript
+const limit = 50; // elements to query per page
+const page = 1; // number of the page you want to select, first page starts at: 1
+const data = await deliveryClient.getDataList("tenantId", "YourProjection", limit, page);
+```
+
+### Gracefully close the clients
+
+You won't lose any data if you don't. Use it for your peace of mind.
+
+```typescript
+client.close();
+```
+
+## Development
+
+You'll need the following apps for a smooth development experience:
+
+-   minikube
+-   lens
+-   okteto
+-   helm
+
+### Running the dev environment
+
+-   Start minikube if not already done:
+
+```shell
+minikube start
+```
+
+-   add mongodb and minio to your lokal kubernetes
+    -   use Makefiles in `./.dev/*`
+-   copy `.env.build` to `.env.build.local`
+    -   add your personal access token (needs read access for private fraym org repositories)
+-   deploy the app to your cluster
+
+```
+make init
+```
+
+-   start okteto
+
+```
+make dev
+```
+
+-   connect your IDE to that okteto instance

package/dist/cmd/projections.d.ts

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

package/dist/cmd/projections.js

@@ -0,0 +1,248 @@
+#! /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 yargs_1 = __importDefault(require("yargs/yargs"));
+const helpers_1 = require("yargs/helpers");
+const dotenv_1 = require("dotenv");
+const graphql_file_loader_1 = require("@graphql-tools/graphql-file-loader");
+const load_1 = require("@graphql-tools/load");
+const graphql_1 = require("graphql");
+const client_1 = require("../management/client");
+const run = async () => {
+    (0, dotenv_1.config)();
+    const argv = await (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
+        .config({ schemaGlob: "./src/**/*.graphql", serverAddress: "127.0.0.1:9000" })
+        .pkgConf("projections").argv;
+    let schemaGlob = argv.schemaGlob;
+    let serverAddress = argv.serverAddress;
+    if (process.env.PROJECTIONS_SCHEMA_GLOB) {
+        schemaGlob = process.env.PROJECTIONS_SCHEMA_GLOB;
+    }
+    if (process.env.PROJECTIONS_SERVER_ADDRESS) {
+        serverAddress = process.env.PROJECTIONS_SERVER_ADDRESS;
+    }
+    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 => {
+        if (!(t instanceof graphql_1.GraphQLObjectType) && !(t instanceof graphql_1.GraphQLEnumType)) {
+            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`);
+        }
+        if (t instanceof graphql_1.GraphQLObjectType) {
+            definitions[name] = getTypeDefinitionFromGraphQLObjectType(t);
+            return;
+        }
+        if (t instanceof graphql_1.GraphQLEnumType) {
+            definitions[name] = getTypeDefinitionFromGraphQLEnumType(t);
+            return;
+        }
+    });
+    return definitions;
+};
+const getTypeDefinitionFromGraphQLEnumType = (t) => {
+    var _a, _b;
+    const name = t.toString();
+    let enumValuesString = "";
+    (_b = (_a = t.astNode) === null || _a === void 0 ? void 0 : _a.values) === null || _b === void 0 ? void 0 : _b.forEach(value => {
+        enumValuesString += `\n\t${value.name.value}`;
+    });
+    const schema = `enum ${name} {${enumValuesString}\n}`;
+    return {
+        isProjection: false,
+        nestedTypes: [],
+        schema,
+    };
+};
+const getTypeDefinitionFromGraphQLObjectType = (t) => {
+    var _a, _b, _c, _d, _e, _f;
+    let isProjection = false;
+    if (((_a = t.astNode) === null || _a === void 0 ? void 0 : _a.directives) && ((_b = t.astNode) === null || _b === void 0 ? void 0 : _b.directives.length) > 0) {
+        const directiveNames = t.astNode.directives.map(directive => directive.name.value);
+        isProjection = directiveNames.includes("identifyBy");
+    }
+    const name = t.toString();
+    let objectDirectivesString = "";
+    let objectFieldsString = "";
+    let nestedTypes = [];
+    (_d = (_c = t.astNode) === null || _c === void 0 ? void 0 : _c.directives) === null || _d === void 0 ? void 0 : _d.forEach(d => {
+        objectDirectivesString += getDirectiveString(d);
+    });
+    (_f = (_e = t.astNode) === null || _e === void 0 ? void 0 : _e.fields) === null || _f === void 0 ? void 0 : _f.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 {
+        isProjection,
+        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\t${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" ||
+                name === "DateTime"
+                ? {
+                    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 });
+    let existingProjections = (await managementClient.getAll()).filter(projectionName => !projectionName.startsWith("Crud"));
+    let createSchema = "";
+    let updateSchema = "";
+    const projectionsToCreate = [];
+    const nestedTypesToCreate = [];
+    const projectionsToUpdate = [];
+    const nestedTypesToUpdate = [];
+    const projectionsToRemove = [];
+    existingProjections.forEach(projectionName => {
+        if (!definitions[projectionName] || !definitions[projectionName].isProjection) {
+            projectionsToRemove.push(projectionName);
+        }
+        else {
+            projectionsToUpdate.push(projectionName);
+            updateSchema += `\n${definitions[projectionName].schema}`;
+            definitions[projectionName].nestedTypes.forEach(nestedTypeName => {
+                if (nestedTypesToUpdate.indexOf(nestedTypeName) !== -1 ||
+                    (definitions[nestedTypeName] && definitions[nestedTypeName].isProjection)) {
+                    return;
+                }
+                updateSchema += `\n${definitions[nestedTypeName].schema}`;
+                nestedTypesToUpdate.push(nestedTypeName);
+            });
+        }
+    });
+    Object.keys(definitions).forEach(newName => {
+        if (!definitions[newName].isProjection || existingProjections.includes(newName)) {
+            return;
+        }
+        projectionsToCreate.push(newName);
+        createSchema += `\n${definitions[newName].schema}`;
+        definitions[newName].nestedTypes.forEach(nestedTypeName => {
+            if (nestedTypesToCreate.indexOf(nestedTypeName) !== -1 ||
+                (definitions[nestedTypeName] && definitions[nestedTypeName].isProjection)) {
+                return;
+            }
+            createSchema += `\n${definitions[nestedTypeName].schema}`;
+            nestedTypesToCreate.push(nestedTypeName);
+        });
+    });
+    if (projectionsToCreate.length > 0) {
+        console.log(`Creating ${projectionsToCreate.length} projections: ${projectionsToCreate}...`);
+        await managementClient.create(createSchema).catch(console.log);
+        console.log(`Created ${projectionsToCreate.length} projections`);
+    }
+    if (projectionsToUpdate.length > 0) {
+        console.log(`Updating ${projectionsToUpdate.length} projections: ${projectionsToUpdate}...`);
+        await managementClient.update(updateSchema).catch(console.log);
+        console.log(`Updated ${projectionsToUpdate.length} projections`);
+    }
+    if (projectionsToRemove.length > 0) {
+        console.log(`Removing ${projectionsToRemove.length} projections: ${projectionsToRemove}...`);
+        await managementClient.remove(projectionsToRemove).catch(console.log);
+        console.log(`Removed ${projectionsToRemove.length} projections`);
+    }
+};

package/dist/config/config.d.ts

@@ -0,0 +1,7 @@
+export interface ClientConfig {
+    serverAddress: string;
+    keepaliveInterval?: number;
+    keepaliveTimeout?: number;
+}
+export declare const getEnvConfig: () => ClientConfig;
+export declare const useConfigDefaults: (config?: ClientConfig) => Required<ClientConfig>;

package/dist/config/config.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useConfigDefaults = exports.getEnvConfig = void 0;
+const dotenv_1 = require("dotenv");
+const getEnvConfig = () => {
+    var _a;
+    (0, dotenv_1.config)();
+    const serverAddress = (_a = process.env.PROJECTIONS_SERVER_ADDRESS) !== null && _a !== void 0 ? _a : "";
+    let keepaliveInterval;
+    let keepaliveTimeout;
+    const keepaliveIntervalString = process.env.PROJECTIONS_CONNECTION_KEEPALIVE_INTERVAL;
+    const keepaliveTimeoutString = process.env.PROJECTIONS_CONNECTION_KEEPALIVE_INTERVAL;
+    if (keepaliveIntervalString) {
+        keepaliveInterval = parseInt(keepaliveIntervalString, 10);
+    }
+    if (keepaliveTimeoutString) {
+        keepaliveTimeout = parseInt(keepaliveTimeoutString, 10);
+    }
+    return {
+        serverAddress,
+        keepaliveInterval,
+        keepaliveTimeout,
+    };
+};
+exports.getEnvConfig = getEnvConfig;
+const useConfigDefaults = (config) => {
+    var _a, _b;
+    if (!config) {
+        config = (0, exports.getEnvConfig)();
+    }
+    console.log(config);
+    return {
+        serverAddress: config.serverAddress,
+        keepaliveTimeout: (_a = config.keepaliveTimeout) !== null && _a !== void 0 ? _a : 3 * 1000,
+        keepaliveInterval: (_b = config.keepaliveInterval) !== null && _b !== void 0 ? _b : 40 * 1000,
+    };
+};
+exports.useConfigDefaults = useConfigDefaults;

package/dist/delivery/client.d.ts

@@ -0,0 +1,9 @@
+import { ClientConfig } from "../config/config";
+import { GetProjectionData } from "./getData";
+import { GetProjectionDataList } from "./getDataList";
+export interface DeliveryClient {
+    getData: (tenantId: string, type: string, id: string, returnEmptyDataIfNotFound?: boolean) => Promise<GetProjectionData | null>;
+    getDataList: (tenantId: string, type: string, limit?: number, page?: number) => Promise<GetProjectionDataList | null>;
+    close: () => Promise<void>;
+}
+export declare const newDeliveryClient: (config?: ClientConfig) => Promise<DeliveryClient>;

package/dist/delivery/client.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newDeliveryClient = void 0;
+const projections_proto_1 = require("@fraym/projections-proto");
+const grpc_js_1 = require("@grpc/grpc-js");
+const config_1 = require("../config/config");
+const getData_1 = require("./getData");
+const getDataList_1 = require("./getDataList");
+const newDeliveryClient = async (config) => {
+    config = (0, config_1.useConfigDefaults)(config);
+    const serviceClient = new projections_proto_1.DeliveryServiceClient(config.serverAddress, grpc_js_1.credentials.createInsecure(), {
+        "grpc.keepalive_time_ms": config.keepaliveInterval,
+        "grpc.keepalive_timeout_ms": config.keepaliveTimeout,
+        "grpc.keepalive_permit_without_calls": 1,
+    });
+    const getData = async (tenantId, projection, id, returnEmptyDataIfNotFound = false) => {
+        return await (0, getData_1.getProjectionData)(tenantId, projection, id, returnEmptyDataIfNotFound, serviceClient);
+    };
+    const getDataList = async (tenantId, projection, limit = 0, page = 1) => {
+        return await (0, getDataList_1.getProjectionDataList)(tenantId, projection, limit, page, serviceClient);
+    };
+    const close = async () => {
+        serviceClient.close();
+    };
+    return {
+        getData,
+        getDataList,
+        close,
+    };
+};
+exports.newDeliveryClient = newDeliveryClient;

package/dist/delivery/getData.d.ts

@@ -0,0 +1,3 @@
+import { DeliveryServiceClient } from "@fraym/projections-proto";
+export declare type GetProjectionData = Record<string, any>;
+export declare const getProjectionData: (tenantId: string, projection: string, dataId: string, returnEmptyDataIfNotFound: boolean, serviceClient: DeliveryServiceClient) => Promise<GetProjectionData | null>;

package/dist/delivery/getData.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectionData = void 0;
+const getProjectionData = async (tenantId, projection, dataId, returnEmptyDataIfNotFound, serviceClient) => {
+    return new Promise((resolve, reject) => {
+        serviceClient.getData({
+            tenantId,
+            projection,
+            dataId,
+            limit: 0,
+            page: 0,
+            returnEmptyDataIfNotFound,
+        }, (error, response) => {
+            if (error) {
+                reject(error.message);
+                return;
+            }
+            if (response.result.length !== 1) {
+                resolve(null);
+                return;
+            }
+            const data = {};
+            const resultData = response.result[0].data;
+            for (const key in resultData) {
+                data[key] = JSON.parse(resultData[key]);
+            }
+            resolve(data);
+        });
+    });
+};
+exports.getProjectionData = getProjectionData;

package/dist/delivery/getDataList.d.ts

@@ -0,0 +1,7 @@
+import { DeliveryServiceClient } from "@fraym/projections-proto";
+export interface GetProjectionDataList {
+    limit: number;
+    page: number;
+    data: Record<string, any>[];
+}
+export declare const getProjectionDataList: (tenantId: string, projection: string, limit: number, page: number, serviceClient: DeliveryServiceClient) => Promise<GetProjectionDataList | null>;

package/dist/delivery/getDataList.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectionDataList = void 0;
+const getProjectionDataList = async (tenantId, projection, limit, page, serviceClient) => {
+    return new Promise((resolve, reject) => {
+        serviceClient.getData({
+            tenantId,
+            projection,
+            dataId: "",
+            limit,
+            page,
+            returnEmptyDataIfNotFound: false,
+        }, (error, response) => {
+            if (error) {
+                reject(error.message);
+                return;
+            }
+            const data = [];
+            for (const result of response.result) {
+                const dataRecord = {};
+                const resultData = result.data;
+                for (const key in resultData) {
+                    dataRecord[key] = JSON.parse(resultData[key]);
+                }
+                data.push(dataRecord);
+            }
+            resolve({
+                limit: response.limit,
+                page: response.page,
+                data,
+            });
+        });
+    });
+};
+exports.getProjectionDataList = getProjectionDataList;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./management/client";
+export * from "./delivery/client";
+export { ClientConfig } from "./config/config";

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./management/client"), exports);
+__exportStar(require("./delivery/client"), exports);

package/dist/management/client.d.ts

@@ -0,0 +1,9 @@
+import { ClientConfig } from "../config/config";
+export interface ManagementClient {
+    create: (schema: string) => Promise<void>;
+    update: (schema: string) => Promise<void>;
+    remove: (projectionNames: string[]) => Promise<void>;
+    getAll: () => Promise<string[]>;
+    close: () => Promise<void>;
+}
+export declare const newManagementClient: (config?: ClientConfig) => Promise<ManagementClient>;

package/dist/management/client.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newManagementClient = void 0;
+const projections_proto_1 = require("@fraym/projections-proto");
+const grpc_js_1 = require("@grpc/grpc-js");
+const config_1 = require("../config/config");
+const create_1 = require("./create");
+const getAll_1 = require("./getAll");
+const remove_1 = require("./remove");
+const update_1 = require("./update");
+const newManagementClient = async (config) => {
+    config = (0, config_1.useConfigDefaults)(config);
+    const serviceClient = new projections_proto_1.ManagementServiceClient(config.serverAddress, grpc_js_1.credentials.createInsecure(), {
+        "grpc.keepalive_time_ms": config.keepaliveInterval,
+        "grpc.keepalive_timeout_ms": config.keepaliveTimeout,
+        "grpc.keepalive_permit_without_calls": 1,
+    });
+    const create = async (schema) => {
+        await (0, create_1.createProjections)(schema, serviceClient);
+    };
+    const update = async (schema) => {
+        await (0, update_1.updateProjections)(schema, serviceClient);
+    };
+    const remove = async (projectionNames) => {
+        await (0, remove_1.removeProjections)(projectionNames, serviceClient);
+    };
+    const getAll = async () => {
+        return await (0, getAll_1.getAllProjections)(serviceClient);
+    };
+    const close = async () => {
+        serviceClient.close();
+    };
+    return {
+        create,
+        update,
+        remove,
+        getAll,
+        close,
+    };
+};
+exports.newManagementClient = newManagementClient;

package/dist/management/create.d.ts

@@ -0,0 +1,2 @@
+import { ManagementServiceClient } from "@fraym/projections-proto";
+export declare const createProjections: (schema: string, serviceClient: ManagementServiceClient) => Promise<void>;

package/dist/management/create.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProjections = void 0;
+const createProjections = async (schema, serviceClient) => {
+    return new Promise((resolve, reject) => {
+        serviceClient.createProjections({
+            schema,
+        }, error => {
+            if (error) {
+                reject(error.message);
+                return;
+            }
+            resolve();
+        });
+    });
+};
+exports.createProjections = createProjections;

package/dist/management/getAll.d.ts

@@ -0,0 +1,2 @@
+import { ManagementServiceClient } from "@fraym/projections-proto";
+export declare const getAllProjections: (serviceClient: ManagementServiceClient) => Promise<string[]>;

package/dist/management/getAll.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllProjections = void 0;
+const getAllProjections = async (serviceClient) => {
+    return new Promise((resolve, reject) => {
+        serviceClient.getProjections({}, (error, response) => {
+            if (error) {
+                reject(error.message);
+                return;
+            }
+            resolve(response.projectionNames);
+        });
+    });
+};
+exports.getAllProjections = getAllProjections;

package/dist/management/remove.d.ts

@@ -0,0 +1,2 @@
+import { ManagementServiceClient } from "@fraym/projections-proto";
+export declare const removeProjections: (projectionNames: string[], serviceClient: ManagementServiceClient) => Promise<void>;

package/dist/management/remove.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeProjections = void 0;
+const removeProjections = async (projectionNames, serviceClient) => {
+    return new Promise((resolve, reject) => {
+        serviceClient.removeProjections({
+            projectionNames,
+        }, error => {
+            if (error) {
+                reject(error.message);
+                return;
+            }
+            resolve();
+        });
+    });
+};
+exports.removeProjections = removeProjections;

package/dist/management/update.d.ts

@@ -0,0 +1,2 @@
+import { ManagementServiceClient } from "@fraym/projections-proto";
+export declare const updateProjections: (schema: string, serviceClient: ManagementServiceClient) => Promise<void>;

package/dist/management/update.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateProjections = void 0;
+const updateProjections = async (schema, serviceClient) => {
+    return new Promise((resolve, reject) => {
+        serviceClient.updateProjections({
+            schema,
+        }, error => {
+            if (error) {
+                reject(error.message);
+                return;
+            }
+            resolve();
+        });
+    });
+};
+exports.updateProjections = updateProjections;

package/package.json

@@ -0,0 +1,47 @@
+{
+    "name": "@fraym/projections",
+    "version": "0.1.0",
+    "license": "UNLICENSED",
+    "homepage": "https://github.com/fraym/projections-nodejs",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/fraym/projections-nodejs.git"
+    },
+    "description": "nodejs client implementation for our projections service",
+    "scripts": {
+        "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 && chmod +x dist/cmd/projections.js",
+        "clean": "rm -rf dist",
+        "prepublishOnly": "npm test && npm run lint && npm run build",
+        "preversion": "npm run lint",
+        "cmd": "dist/cmd/projections.js"
+    },
+    "files": [
+        "dist/**/*"
+    ],
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "bin": {
+        "projections": "dist/cmd/projections.js"
+    },
+    "dependencies": {
+        "@fraym/projections-proto": "^1.0.0-alpha.9",
+        "@graphql-tools/graphql-file-loader": "^7.5.11",
+        "@graphql-tools/load": "^7.8.6",
+        "@grpc/grpc-js": "^1.7.2",
+        "dotenv": "^16.0.3",
+        "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",
+        "uuid": "^9.0.0"
+    },
+    "prettier": "@becklyn/prettier"
+}