@fraym/crud 0.16.2 → 0.17.1

package/README.md

@@ -90,47 +90,86 @@ await managementClient.removeTypes(["YourCrudType"]);
 const list = await managementClient.getAllTypes();
 ```
 
+### Authorization
+
+All delivery client functions make use of the `AuthData` object.
+This data is used to check access for the desired action.
+
+You can add the `FRAYM_AUTH_OWNER` scope in case you are performing an action that is no subject to restrictions.
+
+Fields:
+
+-   `tenantId`: Id of the tenant to use
+-   `scopes`: Slice of scopes to use for the action
+-   `data`: Data that is used in directives like `@filterFromJwtData`
+
+### Event Metadata
+
+You can specify the correlation and causation IDs for the upsert and delete functions. The `eventMetadata` parameter is optional for all these functions and has the following structure:
+
+```typescript
+const eventMetadata = {
+    correlationId: "some-correlation-id",
+    causationId: "some-causation-id",
+};
+```
+
 ### Create data
 
 The name of `YourCrudType` has to equal your type name in your schema (also in casing).
 
 ```typescript
-const { id } = await client.create("tenantId", "YourCrudType", {
+const response = await client.create<any>("YourCrudType", authData, {
     // values here
 });
 ```
 
+The response contains the following fields:
+
+In case of no validation errors:
+
+-   `data`: The new data after your create action
+
+In case of validation errors:
+
+-   `validationErrors`: List of global validation errors that are not related to a single field
+-   `fieldValidationErrors`: Validation errors mapped by the name of the field that they relate to
+
 ### Update data
 
 The name of `YourCrudType` has to equal your type name in your schema (also in casing).
-The `id` has to match the id of the data that you want to update.
 
 ```typescript
-await client.update("tenantId", "YourCrudType", "id", {
+const response = await client.update<any>("YourCrudType", authData, {
     // values here
 });
 ```
 
-### Delete data
+The response contains the following fields:
 
-The name of `YourCrudType` has to equal your type name in your schema (also in casing).
+In case of no validation errors:
 
-Delete all data of a type:
+-   `data`: The new data after your create action
 
-```typescript
-await client.delete("tenantId", "YourCrudType");
-```
+In case of validation errors:
+
+-   `validationErrors`: List of global validation errors that are not related to a single field
+-   `fieldValidationErrors`: Validation errors mapped by the name of the field that they relate to
+
+### Delete data
+
+The name of `YourCrudType` has to equal your type name in your schema (also in casing).
 
 Delete data matching a specific ID:
 
 ```typescript
-await client.delete("tenantId", "YourCrudType", "id");
+const numberOfDeletedEntries = await client.deleteDataById("YourCrudType", authData, "id");
 ```
 
 Delete data matching a filter (see filter parameter for `getDataList` for details):
 
 ```typescript
-await client.delete("tenantId", "YourCrudType", undefined, {
+const numberOfDeletedEntries = await client.deleteDataByFilter("YourCrudType", authData, {
     fields: {
         fieldName: {
             operation: "equals",
@@ -143,17 +182,31 @@ await client.delete("tenantId", "YourCrudType", undefined, {
 
 ### Get a single data element
 
-The name of `YourCrudType` has to equal your type name in your schema (also in casing).
-The `id` has to match the id of the data that you want to get.
+A filter could look like this:
 
-```typescript
-const data = await client.getData("tenantId", "YourCrudType", "id");
+```go
+const filter := {
+	fields: {
+        fieldName: {
+            operation: "equals",
+            type: "Int",
+            value: 123,
+        },
+    },
+}
 ```
 
-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:
+The name of `YourCrudType` has to equal your type name in your schema (also in casing).
+The `id` has to match the id of the data that you want to get.
 
 ```typescript
-const data = await client.getData("tenantId", "YourCrudType", "id", true);
+const data = await client.getData(
+    "YourCrudType",
+    authData,
+    "id",
+    filter,
+    returnEmptyDataIfNotFound
+);
 ```
 
 ### Get (paginated / filtered / ordered) data
@@ -163,21 +216,28 @@ The name of `YourCrudType` has to equal your type name in your schema (also in c
 No pagination:
 
 ```typescript
-const data = await client.getDataList("tenantId", "YourCrudType");
+const dataList = await client.getDataList("YourCrudType", authData);
 ```
 
+The dataList response contains the following fields:
+
+-   `limit`: The pagination limit
+-   `page`: The pagination page
+-   `total`: The total amount of elements matching the given filter
+-   `data`: The selected data
+
 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 client.getDataList("tenantId", "YourCrudType", limit, page);
+const dataList = await client.getDataList("YourCrudType", authData, limit, page);
 ```
 
 With filter:
 
 ```typescript
-const data = await client.getDataList("tenantId", "YourCrudType", undefined, undefined, {
+const dataList = await client.getDataList("YourCrudType", authData, undefined, undefined, {
     fields: {
         fieldName: {
             operation: "equals",
@@ -232,15 +292,22 @@ With order:
 All order definitions are prioritized in the order that they are defined (the first definition is prioritized over the second).
 
 ```typescript
-const data = await client.getDataList("tenantId", "YourCrudType", undefined, undefined, undefined, [
-    {
-        field: "fieldName",
-        descending: true, // omit this value for asc order
-    },
-]);
+const dataList = await client.getDataList(
+    "YourCrudType",
+    authData,
+    undefined,
+    undefined,
+    undefined,
+    [
+        {
+            field: "fieldName",
+            descending: true, // omit this value for asc order
+        },
+    ]
+);
 ```
 
-### Gracefully close the clients
+### Gracefully close the client
 
 You won't lose any data if you don't. Use it for your peace of mind.
 

package/dist/delivery/auth.d.ts

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

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

@@ -1,14 +1,18 @@
 import { DeliveryClientConfig } from "../config/config";
-import { CreatedCrudData } from "./create";
+import { CreateResponse } from "./create";
+import { UpdateResponse } from "./update";
 import { GetCrudDataList } from "./getDataList";
 import { Filter } from "./filter";
 import { Order } from "./order";
+import { AuthData } from "./auth";
+import { EventMetadata } from "./eventMetadata";
 export interface DeliveryClient {
-    create: (tenantId: string, type: string, data: Record<string, any>, id?: string) => Promise<CreatedCrudData>;
-    update: (tenantId: string, type: string, id: string, data: Record<string, any>) => Promise<void>;
-    delete: (tenantId: string, type: string, id?: string, filter?: Filter) => Promise<void>;
-    getData: <T extends {}>(tenantId: string, type: string, id: string, returnEmptyDataIfNotFound?: boolean) => Promise<T>;
-    getDataList: <T extends {}>(tenantId: string, type: string, limit?: number, page?: number, filter?: Filter, order?: Order[]) => Promise<GetCrudDataList<T>>;
+    getData: <T extends {}>(type: string, authData: AuthData, id: string, filter?: Filter, returnEmptyDataIfNotFound?: boolean) => Promise<T | null>;
+    getDataList: <T extends {}>(type: string, authData: AuthData, limit?: number, page?: number, filter?: Filter, order?: Order[]) => Promise<GetCrudDataList<T>>;
+    create: <T extends {}>(type: string, authData: AuthData, data: Record<string, any>, id?: string, eventMetadata?: EventMetadata) => Promise<CreateResponse<T>>;
+    update: <T extends {}>(type: string, authData: AuthData, id: string, data: Record<string, any>, eventMetadata?: EventMetadata) => Promise<UpdateResponse<T>>;
+    deleteDataById: (type: string, authData: AuthData, id: string, eventMetadata?: EventMetadata) => Promise<number>;
+    deleteDataByFilter: (type: string, authData: AuthData, filter?: Filter, eventMetadata?: EventMetadata) => Promise<number>;
     close: () => Promise<void>;
 }
 export declare const newDeliveryClient: (config?: DeliveryClientConfig) => Promise<DeliveryClient>;

package/dist/delivery/client.js

@@ -16,30 +16,34 @@ const newDeliveryClient = async (config) => {
         "grpc.keepalive_timeout_ms": config.keepaliveTimeout,
         "grpc.keepalive_permit_without_calls": 1,
     });
-    const create = async (tenantId, type, data, id = "") => {
-        return await (0, create_1.createCrudData)(tenantId, type, data, id, serviceClient);
+    const getData = async (type, authData, id, filter = { fields: {}, and: [], or: [] }, returnEmptyDataIfNotFound = false) => {
+        return await (0, getData_1.getCrudData)(type, authData, id, filter, returnEmptyDataIfNotFound, serviceClient);
     };
-    const update = async (tenantId, type, id, data) => {
-        return await (0, update_1.updateCrudData)(tenantId, type, id, data, serviceClient);
+    const getDataList = async (type, authData, limit = 0, page = 1, filter = { fields: {}, and: [], or: [] }, order = []) => {
+        return await (0, getDataList_1.getCrudDataList)(type, authData, limit, page, filter, order, serviceClient);
     };
-    const deleter = async (tenantId, type, id = "", filter = { fields: {}, and: [], or: [] }) => {
-        return await (0, delete_1.deleteCrudData)(tenantId, type, id, filter, serviceClient);
+    const create = async (type, authData, data, id = "", eventMetadata = { causationId: "", correlationId: "" }) => {
+        return await (0, create_1.createCrudData)(type, authData, data, id, eventMetadata, serviceClient);
     };
-    const getData = async (tenantId, type, id, returnEmptyDataIfNotFound = false) => {
-        return await (0, getData_1.getCrudData)(tenantId, type, id, returnEmptyDataIfNotFound, serviceClient);
+    const update = async (type, authData, id, data, eventMetadata = { causationId: "", correlationId: "" }) => {
+        return await (0, update_1.updateCrudData)(type, authData, id, data, eventMetadata, serviceClient);
     };
-    const getDataList = async (tenantId, type, limit = 0, page = 1, filter = { fields: {}, and: [], or: [] }, order = []) => {
-        return await (0, getDataList_1.getCrudDataList)(tenantId, type, limit, page, filter, order, serviceClient);
+    const deleteDataById = async (type, authData, id, eventMetadata = { causationId: "", correlationId: "" }) => {
+        return await (0, delete_1.deleteCrudData)(type, authData, id, { fields: {}, and: [], or: [] }, eventMetadata, serviceClient);
+    };
+    const deleteDataByFilter = async (type, authData, filter = { fields: {}, and: [], or: [] }, eventMetadata = { causationId: "", correlationId: "" }) => {
+        return await (0, delete_1.deleteCrudData)(type, authData, "", filter, eventMetadata, serviceClient);
     };
     const close = async () => {
         serviceClient.close();
     };
     return {
-        create,
-        update,
-        delete: deleter,
         getData,
         getDataList,
+        create,
+        update,
+        deleteDataById,
+        deleteDataByFilter,
         close,
     };
 };

package/dist/delivery/create.d.ts

@@ -1,5 +1,14 @@
 import { DeliveryServiceClient } from "@fraym/crud-proto";
-export interface CreatedCrudData {
-    id: string;
+import { AuthData } from "./auth";
+import { EventMetadata } from "./eventMetadata";
+export type CreateResponse<T extends {}> = CreateSuccessResponse<T> | CreateValidationResponse;
+export interface CreateSuccessResponse<T extends {}> {
+    data: T;
 }
-export declare const createCrudData: (tenantId: string, type: string, data: Record<string, any>, id: string, serviceClient: DeliveryServiceClient) => Promise<CreatedCrudData>;
+export interface CreateValidationResponse {
+    validationErrors: string[];
+    fieldValidationErrors: Record<string, string>;
+}
+export declare const isCreateSuccessResponse: <T extends {}>(response: CreateResponse<T>) => response is CreateSuccessResponse<T>;
+export declare const isCreateValidationResponse: <T extends {}>(response: CreateResponse<T>) => response is CreateValidationResponse;
+export declare const createCrudData: <T extends {}>(type: string, authData: AuthData, data: Record<string, any>, id: string, eventMetadata: EventMetadata, serviceClient: DeliveryServiceClient) => Promise<CreateResponse<T>>;

package/dist/delivery/create.js

@@ -1,24 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCrudData = void 0;
-const createCrudData = async (tenantId, type, data, id, serviceClient) => {
+exports.createCrudData = exports.isCreateValidationResponse = exports.isCreateSuccessResponse = void 0;
+const auth_1 = require("./auth");
+const isCreateSuccessResponse = (response) => {
+    return response.hasOwnProperty("data");
+};
+exports.isCreateSuccessResponse = isCreateSuccessResponse;
+const isCreateValidationResponse = (response) => {
+    return !response.hasOwnProperty("data");
+};
+exports.isCreateValidationResponse = isCreateValidationResponse;
+const createCrudData = async (type, authData, data, id, eventMetadata, serviceClient) => {
     const requestData = {};
     for (const key in data) {
         requestData[key] = JSON.stringify(data[key]);
     }
     return new Promise((resolve, reject) => {
         serviceClient.createEntry({
-            tenantId,
             type,
+            auth: (0, auth_1.getProtobufAuthData)(authData),
             data: requestData,
             id,
+            eventMetadata,
         }, (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({
-                id: response.id,
+                data,
             });
         });
     });

package/dist/delivery/delete.d.ts

@@ -1,3 +1,5 @@
 import { DeliveryServiceClient } from "@fraym/crud-proto";
+import { AuthData } from "./auth";
+import { EventMetadata } from "./eventMetadata";
 import { Filter } from "./filter";
-export declare const deleteCrudData: (tenantId: string, type: string, id: string, filter: Filter, serviceClient: DeliveryServiceClient) => Promise<void>;
+export declare const deleteCrudData: (type: string, authData: AuthData, id: string, filter: Filter, eventMetadata: EventMetadata, serviceClient: DeliveryServiceClient) => Promise<number>;

package/dist/delivery/delete.js

@@ -1,20 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteCrudData = void 0;
+const auth_1 = require("./auth");
 const filter_1 = require("./filter");
-const deleteCrudData = async (tenantId, type, id, filter, serviceClient) => {
+const deleteCrudData = async (type, authData, id, filter, eventMetadata, serviceClient) => {
     return new Promise((resolve, reject) => {
         serviceClient.deleteEntries({
-            tenantId,
             type,
+            auth: (0, auth_1.getProtobufAuthData)(authData),
             id,
             filter: (0, filter_1.getProtobufEntryFilter)(filter),
-        }, error => {
+            eventMetadata,
+        }, (error, response) => {
             if (error) {
                 reject(error.message);
                 return;
             }
-            resolve();
+            resolve(response.numberOfDeletedEntries);
         });
     });
 };

package/dist/delivery/eventMetadata.d.ts

@@ -0,0 +1,4 @@
+export interface EventMetadata {
+    correlationId: string;
+    causationId: string;
+}

package/dist/delivery/eventMetadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/delivery/getData.d.ts

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

package/dist/delivery/getData.js

@@ -1,29 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCrudData = void 0;
-const getCrudData = async (tenantId, type, id, returnEmptyDataIfNotFound, serviceClient) => {
+const auth_1 = require("./auth");
+const filter_1 = require("./filter");
+const getCrudData = async (type, authData, id, filter, returnEmptyDataIfNotFound, serviceClient) => {
     return new Promise((resolve, reject) => {
-        serviceClient.getEntries({
-            tenantId,
+        serviceClient.getEntry({
             type,
+            auth: (0, auth_1.getProtobufAuthData)(authData),
+            filter: (0, filter_1.getProtobufEntryFilter)(filter),
             id,
-            limit: 0,
-            page: 0,
             returnEmptyDataIfNotFound,
-            filter: { fields: {}, and: [], or: [] },
-            order: [],
         }, (error, response) => {
             if (error) {
                 reject(error.message);
                 return;
             }
-            if (response.result.length !== 1) {
-                throw new Error("did not find the requested crud entry");
+            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,9 +1,11 @@
 import { DeliveryServiceClient } from "@fraym/crud-proto";
+import { AuthData } from "./auth";
 import { Filter } from "./filter";
 import { Order } from "./order";
 export interface GetCrudDataList<T extends {}> {
     limit: number;
     page: number;
+    total: number;
     data: T[];
 }
-export declare const getCrudDataList: <T extends {}>(tenantId: string, type: string, limit: number, page: number, filter: Filter, order: Order[], serviceClient: DeliveryServiceClient) => Promise<GetCrudDataList<T>>;
+export declare const getCrudDataList: <T extends {}>(type: string, authData: AuthData, limit: number, page: number, filter: Filter, order: Order[], serviceClient: DeliveryServiceClient) => Promise<GetCrudDataList<T>>;

package/dist/delivery/getDataList.js

@@ -1,17 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCrudDataList = void 0;
+const auth_1 = require("./auth");
 const filter_1 = require("./filter");
 const order_1 = require("./order");
-const getCrudDataList = async (tenantId, type, limit, page, filter, order, serviceClient) => {
+const getCrudDataList = async (type, authData, limit, page, filter, order, serviceClient) => {
     return new Promise((resolve, reject) => {
-        serviceClient.getEntries({
-            tenantId,
+        serviceClient.getEntryList({
             type,
-            id: "",
+            auth: (0, auth_1.getProtobufAuthData)(authData),
             limit,
             page,
-            returnEmptyDataIfNotFound: false,
             filter: (0, filter_1.getProtobufEntryFilter)(filter),
             order: (0, order_1.getProtobufEntryOrder)(order),
         }, (error, response) => {
@@ -31,6 +30,7 @@ const getCrudDataList = async (tenantId, type, limit, page, filter, order, servi
             resolve({
                 limit: response.limit,
                 page: response.page,
+                total: response.total,
                 data,
             });
         });

package/dist/delivery/update.d.ts

@@ -1,2 +1,14 @@
 import { DeliveryServiceClient } from "@fraym/crud-proto";
-export declare const updateCrudData: (tenantId: string, type: string, id: string, data: Record<string, any>, serviceClient: DeliveryServiceClient) => Promise<void>;
+import { AuthData } from "./auth";
+import { EventMetadata } from "./eventMetadata";
+export type UpdateResponse<T extends {}> = UpdateSuccessResponse<T> | UpdateValidationResponse;
+export interface UpdateSuccessResponse<T extends {}> {
+    data: T;
+}
+export interface UpdateValidationResponse {
+    validationErrors: string[];
+    fieldValidationErrors: Record<string, string>;
+}
+export declare const isUpdateSuccessResponse: <T extends {}>(response: UpdateResponse<T>) => response is UpdateSuccessResponse<T>;
+export declare const isUpdateValidationResponse: <T extends {}>(response: UpdateResponse<T>) => response is UpdateValidationResponse;
+export declare const updateCrudData: <T extends {}>(type: string, authData: AuthData, id: string, data: Record<string, any>, eventMetadata: EventMetadata, serviceClient: DeliveryServiceClient) => Promise<UpdateResponse<T>>;

package/dist/delivery/update.js

@@ -1,23 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateCrudData = void 0;
-const updateCrudData = async (tenantId, type, id, data, serviceClient) => {
+exports.updateCrudData = exports.isUpdateValidationResponse = exports.isUpdateSuccessResponse = void 0;
+const auth_1 = require("./auth");
+const isUpdateSuccessResponse = (response) => {
+    return response.hasOwnProperty("data");
+};
+exports.isUpdateSuccessResponse = isUpdateSuccessResponse;
+const isUpdateValidationResponse = (response) => {
+    return !response.hasOwnProperty("data");
+};
+exports.isUpdateValidationResponse = isUpdateValidationResponse;
+const updateCrudData = async (type, authData, id, data, eventMetadata, serviceClient) => {
     const requestData = {};
     for (const key in data) {
         requestData[key] = JSON.stringify(data[key]);
     }
     return new Promise((resolve, reject) => {
         serviceClient.updateEntry({
-            tenantId,
             type,
-            id,
+            auth: (0, auth_1.getProtobufAuthData)(authData),
             data: requestData,
-        }, error => {
+            id,
+            eventMetadata,
+        }, (error, response) => {
             if (error) {
                 reject(error.message);
                 return;
             }
-            resolve();
+            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,
+            });
         });
     });
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraym/crud",
-    "version": "0.16.2",
+    "version": "0.17.1",
     "license": "UNLICENSED",
     "homepage": "https://github.com/fraym/crud-nodejs",
     "repository": {
@@ -27,7 +27,7 @@
         "crud": "dist/cmd/crud.js"
     },
     "dependencies": {
-        "@fraym/crud-proto": "1.0.0-alpha.12",
+        "@fraym/crud-proto": "1.0.0-alpha.17",
         "@graphql-tools/graphql-file-loader": "^7.5.14",
         "@graphql-tools/load": "^7.8.9",
         "@grpc/grpc-js": "^1.8.7",