@fraym/projections 0.9.0 → 0.10.1

package/dist/cmd/projections.js

@@ -223,14 +223,20 @@ const addNestedTypesToSchema = (definitions, nestedTypeName, nestedTypes) => {
         };
     }
     let newSchema = definitions[nestedTypeName].schema;
-    nestedTypes.push(nestedTypeName);
+    if (!nestedTypes.includes(nestedTypeName)) {
+        nestedTypes.push(nestedTypeName);
+    }
     nestedTypeDefinition.nestedTypes.forEach(nestedNestedTypeName => {
         const nestedSchemaData = addNestedTypesToSchema(definitions, nestedNestedTypeName, nestedTypes);
         if (nestedSchemaData.schema === "") {
             return;
         }
         newSchema += `\n${nestedSchemaData.schema}`;
-        nestedTypes.push(...nestedSchemaData.nestedTypes);
+        nestedSchemaData.nestedTypes.forEach(nestedType => {
+            if (!nestedTypes.includes(nestedType)) {
+                nestedTypes.push(nestedType);
+            }
+        });
     });
     return {
         schema: newSchema,
@@ -262,7 +268,11 @@ const migrateSchemas = async (definitions, serverAddress, namespace) => {
                     return;
                 }
                 updateSchema += `\n${nestedSchemaData.schema}`;
-                nestedTypesToUpdate.push(...nestedSchemaData.nestedTypes);
+                nestedSchemaData.nestedTypes.forEach(nestedType => {
+                    if (!nestedTypesToUpdate.includes(nestedType)) {
+                        nestedTypesToUpdate.push(nestedType);
+                    }
+                });
             });
         }
     });
@@ -278,7 +288,11 @@ const migrateSchemas = async (definitions, serverAddress, namespace) => {
                 return;
             }
             createSchema += `\n${nestedSchemaData.schema}`;
-            nestedTypesToCreate.push(...nestedSchemaData.nestedTypes);
+            nestedSchemaData.nestedTypes.forEach(nestedType => {
+                if (!nestedTypesToCreate.includes(nestedType)) {
+                    nestedTypesToCreate.push(nestedType);
+                }
+            });
         });
     });
     if (projectionsToCreate.length > 0) {

package/dist/delivery/auth.d.ts

@@ -0,0 +1,7 @@
+import { AuthData as PbAuthData } from "@fraym/projections-proto";
+export interface AuthData {
+    tenantId: string;
+    scopes: string[];
+    data: Record<string, any>;
+}
+export declare const getProtobufAuthData: (auth: AuthData) => PbAuthData;

package/dist/delivery/auth.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProtobufAuthData = void 0;
+const getProtobufAuthData = (auth) => {
+    const data = {};
+    for (let key in auth.data) {
+        data[key] = JSON.stringify(auth.data[key]);
+    }
+    return {
+        tenantId: auth.tenantId,
+        scopes: auth.scopes,
+        data,
+    };
+};
+exports.getProtobufAuthData = getProtobufAuthData;

package/dist/delivery/client.d.ts

@@ -2,9 +2,14 @@ import { ClientConfig } from "../config/config";
 import { Filter } from "./filter";
 import { GetProjectionDataList } from "./getDataList";
 import { Order } from "./order";
+import { AuthData } from "./auth";
+import { UpsertResponse } from "./upsert";
 export interface DeliveryClient {
-    getData: <T extends {}>(tenantId: string, type: string, id: string, returnEmptyDataIfNotFound?: boolean) => Promise<T | null>;
-    getDataList: <T extends {}>(tenantId: string, type: string, limit?: number, page?: number, filter?: Filter, order?: Order[]) => Promise<GetProjectionDataList<T> | null>;
+    getData: <T extends {}>(projection: string, authData: AuthData, id: string, filter?: Filter, returnEmptyDataIfNotFound?: boolean) => Promise<T | null>;
+    getDataList: <T extends {}>(projection: string, authData: AuthData, limit?: number, page?: number, filter?: Filter, order?: Order[]) => Promise<GetProjectionDataList<T> | null>;
+    upsertData: <T extends {}>(projection: string, authData: AuthData, dataId: string, payload: T) => Promise<UpsertResponse<T>>;
+    deleteDataById: (projection: string, authData: AuthData, dataId: string) => Promise<number>;
+    deleteDataByFilter: (projection: string, authData: AuthData, filter?: Filter) => Promise<number>;
     close: () => Promise<void>;
 }
 export declare const newDeliveryClient: (config?: ClientConfig) => Promise<DeliveryClient>;

package/dist/delivery/client.js

@@ -6,6 +6,8 @@ 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 upsert_1 = require("./upsert");
+const delete_1 = require("./delete");
 const newDeliveryClient = async (config) => {
     config = (0, config_1.useConfigDefaults)(config);
     const serviceClient = new projections_proto_1.DeliveryServiceClient(config.serverAddress, grpc_js_1.credentials.createInsecure(), {
@@ -13,11 +15,20 @@ const newDeliveryClient = async (config) => {
         "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 getData = async (projection, auth, id, filter = { fields: {}, and: [], or: [] }, returnEmptyDataIfNotFound = false) => {
+        return await (0, getData_1.getProjectionData)(projection, auth, id, filter, returnEmptyDataIfNotFound, serviceClient);
     };
-    const getDataList = async (tenantId, projection, limit = 0, page = 1, filter = { fields: {}, and: [], or: [] }, order = []) => {
-        return await (0, getDataList_1.getProjectionDataList)(tenantId, projection, limit, page, filter, order, serviceClient);
+    const getDataList = async (projection, auth, limit = 0, page = 1, filter = { fields: {}, and: [], or: [] }, order = []) => {
+        return await (0, getDataList_1.getProjectionDataList)(projection, auth, limit, page, filter, order, serviceClient);
+    };
+    const upsertData = async (projection, authData, dataId, payload) => {
+        return (0, upsert_1.upsertProjectionData)(projection, authData, dataId, payload, serviceClient);
+    };
+    const deleteDataById = async (projection, authData, dataId) => {
+        return (0, delete_1.deleteProjectionData)(projection, authData, dataId, { fields: {}, and: [], or: [] }, serviceClient);
+    };
+    const deleteDataByFilter = async (projection, authData, filter = { fields: {}, and: [], or: [] }) => {
+        return (0, delete_1.deleteProjectionData)(projection, authData, "", filter, serviceClient);
     };
     const close = async () => {
         serviceClient.close();
@@ -25,6 +36,9 @@ const newDeliveryClient = async (config) => {
     return {
         getData,
         getDataList,
+        upsertData,
+        deleteDataById,
+        deleteDataByFilter,
         close,
     };
 };

package/dist/delivery/delete.d.ts

@@ -0,0 +1,4 @@
+import { DeliveryServiceClient } from "@fraym/projections-proto";
+import { AuthData } from "./auth";
+import { Filter } from "./filter";
+export declare const deleteProjectionData: (projection: string, auth: AuthData, dataId: string, filter: Filter, serviceClient: DeliveryServiceClient) => Promise<number>;

package/dist/delivery/delete.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteProjectionData = void 0;
+const auth_1 = require("./auth");
+const filter_1 = require("./filter");
+const deleteProjectionData = async (projection, auth, dataId, filter, serviceClient) => {
+    return new Promise((resolve, reject) => {
+        serviceClient.deleteData({
+            projection,
+            auth: (0, auth_1.getProtobufAuthData)(auth),
+            dataId,
+            filter: (0, filter_1.getProtobufDataFilter)(filter),
+        }, (error, response) => {
+            if (error) {
+                reject(error.message);
+                return;
+            }
+            resolve(response.numberOfDeletedEntries);
+        });
+    });
+};
+exports.deleteProjectionData = deleteProjectionData;

package/dist/delivery/getData.d.ts

@@ -1,2 +1,4 @@
 import { DeliveryServiceClient } from "@fraym/projections-proto";
-export declare const getProjectionData: <T extends {}>(tenantId: string, projection: string, dataId: string, returnEmptyDataIfNotFound: boolean, serviceClient: DeliveryServiceClient) => Promise<T | null>;
+import { AuthData } from "./auth";
+import { Filter } from "./filter";
+export declare const getProjectionData: <T extends {}>(projection: string, auth: AuthData, dataId: string, filter: Filter, returnEmptyDataIfNotFound: boolean, serviceClient: DeliveryServiceClient) => Promise<T | null>;

package/dist/delivery/getData.js

@@ -1,30 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getProjectionData = void 0;
-const getProjectionData = async (tenantId, projection, dataId, returnEmptyDataIfNotFound, serviceClient) => {
+const auth_1 = require("./auth");
+const filter_1 = require("./filter");
+const getProjectionData = async (projection, auth, dataId, filter, returnEmptyDataIfNotFound, serviceClient) => {
     return new Promise((resolve, reject) => {
         serviceClient.getData({
-            tenantId,
             projection,
+            auth: (0, auth_1.getProtobufAuthData)(auth),
             dataId,
-            limit: 0,
-            page: 0,
+            filter: (0, filter_1.getProtobufDataFilter)(filter),
             returnEmptyDataIfNotFound,
-            filter: { fields: {}, and: [], or: [] },
-            order: [],
         }, (error, response) => {
             if (error) {
                 reject(error.message);
                 return;
             }
-            if (response.result.length !== 1) {
+            const result = response.result;
+            if (!result) {
                 resolve(null);
                 return;
             }
             const data = {};
-            const resultData = response.result[0].data;
-            for (const key in resultData) {
-                data[key] = JSON.parse(resultData[key]);
+            for (const key in result.data) {
+                data[key] = JSON.parse(result.data[key]);
             }
             resolve(data);
         });

package/dist/delivery/getDataList.d.ts

@@ -1,4 +1,5 @@
 import { DeliveryServiceClient } from "@fraym/projections-proto";
+import { AuthData } from "./auth";
 import { Filter } from "./filter";
 import { Order } from "./order";
 export interface GetProjectionDataList<T extends {}> {
@@ -6,4 +7,4 @@ export interface GetProjectionDataList<T extends {}> {
     page: number;
     data: T[];
 }
-export declare const getProjectionDataList: <T extends {}>(tenantId: string, projection: string, limit: number, page: number, filter: Filter, order: Order[], serviceClient: DeliveryServiceClient) => Promise<GetProjectionDataList<T> | null>;
+export declare const getProjectionDataList: <T extends {}>(projection: string, auth: AuthData, limit: number, page: number, filter: Filter, order: Order[], serviceClient: DeliveryServiceClient) => Promise<GetProjectionDataList<T> | null>;

package/dist/delivery/getDataList.js

@@ -1,17 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getProjectionDataList = void 0;
+const auth_1 = require("./auth");
 const filter_1 = require("./filter");
 const order_1 = require("./order");
-const getProjectionDataList = async (tenantId, projection, limit, page, filter, order, serviceClient) => {
+const getProjectionDataList = async (projection, auth, limit, page, filter, order, serviceClient) => {
     return new Promise((resolve, reject) => {
-        serviceClient.getData({
-            tenantId,
+        serviceClient.getDataList({
             projection,
-            dataId: "",
+            auth: (0, auth_1.getProtobufAuthData)(auth),
             limit,
             page,
-            returnEmptyDataIfNotFound: false,
             filter: (0, filter_1.getProtobufDataFilter)(filter),
             order: (0, order_1.getProtobufDataOrder)(order),
         }, (error, response) => {

package/dist/delivery/upsert.d.ts

@@ -0,0 +1,13 @@
+import { DeliveryServiceClient } from "@fraym/projections-proto";
+import { AuthData } from "./auth";
+export type UpsertResponse<T extends {}> = UpsertSuccessResponse<T> | UpsertValidationResponse;
+export interface UpsertSuccessResponse<T extends {}> {
+    data: T;
+}
+export interface UpsertValidationResponse {
+    validationErrors: string[];
+    fieldValidationErrors: Record<string, string>;
+}
+export declare const isUpsertSuccessResponse: <T extends {}>(response: UpsertResponse<T>) => response is UpsertSuccessResponse<T>;
+export declare const isUpsertValidationResponse: <T extends {}>(response: UpsertResponse<T>) => response is UpsertValidationResponse;
+export declare const upsertProjectionData: <T extends {}>(projection: string, auth: AuthData, dataId: string, payload: T, serviceClient: DeliveryServiceClient) => Promise<UpsertResponse<T>>;

package/dist/delivery/upsert.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upsertProjectionData = exports.isUpsertValidationResponse = exports.isUpsertSuccessResponse = void 0;
+const auth_1 = require("./auth");
+const isUpsertSuccessResponse = (response) => {
+    return response.hasOwnProperty("data");
+};
+exports.isUpsertSuccessResponse = isUpsertSuccessResponse;
+const isUpsertValidationResponse = (response) => {
+    return !response.hasOwnProperty("data");
+};
+exports.isUpsertValidationResponse = isUpsertValidationResponse;
+const upsertProjectionData = async (projection, auth, dataId, payload, serviceClient) => {
+    return new Promise((resolve, reject) => {
+        serviceClient.upsertData({
+            projection,
+            auth: (0, auth_1.getProtobufAuthData)(auth),
+            dataId,
+            payload,
+        }, (error, response) => {
+            if (error) {
+                reject(error.message);
+                return;
+            }
+            if (response.validationErrors || response.fieldValidationErrors) {
+                resolve({
+                    validationErrors: response.validationErrors,
+                    fieldValidationErrors: response.fieldValidationErrors,
+                });
+                return;
+            }
+            const data = {};
+            for (const key in response.newData) {
+                data[key] = JSON.parse(response.newData[key]);
+            }
+            resolve({
+                data,
+            });
+        });
+    });
+};
+exports.upsertProjectionData = upsertProjectionData;

package/dist/index.d.ts

@@ -1,5 +1,8 @@
+export { ClientConfig, getEnvConfig } from "./config/config";
 export * from "./management/client";
 export * from "./delivery/client";
 export { Filter, FieldFilter } from "./delivery/filter";
+export { GetProjectionDataList } from "./delivery/getDataList";
+export { AuthData } from "./delivery/auth";
 export { Order } from "./delivery/order";
-export { ClientConfig, getEnvConfig } from "./config/config";
+export { UpsertResponse, UpsertSuccessResponse, UpsertValidationResponse, isUpsertSuccessResponse, isUpsertValidationResponse, } from "./delivery/upsert";

package/dist/index.js

@@ -14,8 +14,11 @@ 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 });
-exports.getEnvConfig = void 0;
-__exportStar(require("./management/client"), exports);
-__exportStar(require("./delivery/client"), exports);
+exports.isUpsertValidationResponse = exports.isUpsertSuccessResponse = exports.getEnvConfig = void 0;
 var config_1 = require("./config/config");
 Object.defineProperty(exports, "getEnvConfig", { enumerable: true, get: function () { return config_1.getEnvConfig; } });
+__exportStar(require("./management/client"), exports);
+__exportStar(require("./delivery/client"), exports);
+var upsert_1 = require("./delivery/upsert");
+Object.defineProperty(exports, "isUpsertSuccessResponse", { enumerable: true, get: function () { return upsert_1.isUpsertSuccessResponse; } });
+Object.defineProperty(exports, "isUpsertValidationResponse", { enumerable: true, get: function () { return upsert_1.isUpsertValidationResponse; } });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraym/projections",
-    "version": "0.9.0",
+    "version": "0.10.1",
     "license": "UNLICENSED",
     "homepage": "https://github.com/fraym/projections-nodejs",
     "repository": {
@@ -27,20 +27,20 @@
         "projections": "dist/cmd/projections.js"
     },
     "dependencies": {
-        "@fraym/projections-proto": "^1.0.0-alpha.12",
-        "@graphql-tools/graphql-file-loader": "^7.5.11",
-        "@graphql-tools/load": "^7.8.6",
-        "@grpc/grpc-js": "^1.8.7",
+        "@fraym/projections-proto": "^1.0.0-alpha.14",
+        "@graphql-tools/graphql-file-loader": "^7.5.16",
+        "@graphql-tools/load": "^7.8.13",
+        "@grpc/grpc-js": "^1.8.12",
         "dotenv": "^16.0.3",
         "graphql": "^16.6.0",
-        "yargs": "^17.6.2"
+        "yargs": "^17.7.1"
     },
     "devDependencies": {
         "@becklyn/prettier": "^1.0.2",
-        "@types/uuid": "^8.3.4",
-        "@types/yargs": "^17.0.13",
-        "prettier": "^2.7.1",
-        "typescript": "^4.8.4",
+        "@types/uuid": "^9.0.1",
+        "@types/yargs": "^17.0.22",
+        "prettier": "^2.8.4",
+        "typescript": "^5.0.2",
         "uuid": "^9.0.0"
     },
     "prettier": "@becklyn/prettier"