@webiny/api-core-ddb 6.3.0-beta.4 → 6.4.0-beta.0

package/security/index.js

@@ -1,476 +1,401 @@
-import WebinyError from "@webiny/error";
+import error from "@webiny/error";
 import { createApiKeyEntity, createRoleEntity, createTeamEntity } from "./definitions/entities.js";
 import { createTable, sortItems } from "@webiny/db-dynamodb";
-export const createStorageOperations = params => {
-  const {
-    table: tableName,
-    documentClient
-  } = params;
-  const table = createTable({
-    name: tableName || process.env.DB_TABLE,
-    documentClient
-  });
-  const entities = {
-    apiKeys: createApiKeyEntity(table.table),
-    roles: createRoleEntity(table.table),
-    teams: createTeamEntity(table.table)
-  };
-  const createApiKeyKeys = ({
-    id,
-    tenant
-  }) => ({
-    PK: `T#${tenant}#API_KEY#${id}`,
-    SK: `A`,
-    GSI_TENANT: tenant,
-    TYPE: "security.apiKey"
-  });
-  const createApiKeyGsiKeys = ({
-    slug,
-    token,
-    tenant
-  }) => ({
-    GSI1_PK: `T#${tenant}#API_KEYS`,
-    GSI1_SK: token,
-    GSI2_PK: `T#${tenant}#API_KEYS`,
-    GSI2_SK: slug
-  });
-  const createRoleKeys = role => ({
-    PK: `T#${role.tenant}#ROLE#${role.id}`,
-    SK: `A`
-  });
-  const createRoleGsiKeys = role => ({
-    GSI1_PK: `T#${role.tenant}#ROLES`,
-    GSI1_SK: role.slug,
-    GSI_TENANT: role.tenant,
-    TYPE: "security.role"
-  });
-  const createTeamKeys = team => ({
-    PK: `T#${team.tenant}#TEAM#${team.id}`,
-    SK: `A`
-  });
-  const createTeamGsiKeys = team => ({
-    GSI1_PK: `T#${team.tenant}#TEAMS`,
-    GSI1_SK: team.slug,
-    GSI_TENANT: team.tenant,
-    TYPE: "security.team"
-  });
-  return {
-    async createApiKey({
-      apiKey
-    }) {
-      const keys = {
-        ...createApiKeyKeys(apiKey),
-        ...createApiKeyGsiKeys(apiKey)
-      };
-      try {
-        await entities.apiKeys.put({
-          data: apiKey,
-          ...keys
+const createStorageOperations = (params)=>{
+    const { table: tableName, documentClient } = params;
+    const table = createTable({
+        name: tableName || process.env.DB_TABLE,
+        documentClient
+    });
+    const entities = {
+        apiKeys: createApiKeyEntity(table.table),
+        roles: createRoleEntity(table.table),
+        teams: createTeamEntity(table.table)
+    };
+    const createApiKeyKeys = ({ id, tenant })=>({
+            PK: `T#${tenant}#API_KEY#${id}`,
+            SK: "A",
+            GSI_TENANT: tenant,
+            TYPE: "security.apiKey"
         });
-      } catch (err) {
-        throw WebinyError.from(err, {
-          message: "Could not create api key.",
-          code: "CREATE_API_KEY_ERROR",
-          data: {
-            keys
-          }
+    const createApiKeyGsiKeys = ({ slug, token, tenant })=>({
+            GSI1_PK: `T#${tenant}#API_KEYS`,
+            GSI1_SK: token,
+            GSI2_PK: `T#${tenant}#API_KEYS`,
+            GSI2_SK: slug
         });
-      }
-    },
-    async createRole({
-      role
-    }) {
-      const keys = {
-        ...createRoleKeys(role),
-        ...createRoleGsiKeys(role)
-      };
-      try {
-        await entities.roles.put({
-          data: role,
-          ...keys
+    const createRoleKeys = (role)=>({
+            PK: `T#${role.tenant}#ROLE#${role.id}`,
+            SK: "A"
         });
-      } catch (err) {
-        throw WebinyError.from(err, {
-          message: "Could not create role.",
-          code: "CREATE_ROLE_ERROR",
-          data: {
-            keys
-          }
+    const createRoleGsiKeys = (role)=>({
+            GSI1_PK: `T#${role.tenant}#ROLES`,
+            GSI1_SK: role.slug,
+            GSI_TENANT: role.tenant,
+            TYPE: "security.role"
         });
-      }
-    },
-    async createTeam({
-      team
-    }) {
-      const keys = {
-        ...createTeamKeys(team),
-        ...createTeamGsiKeys(team)
-      };
-      try {
-        await entities.teams.put({
-          data: team,
-          ...keys
+    const createTeamKeys = (team)=>({
+            PK: `T#${team.tenant}#TEAM#${team.id}`,
+            SK: "A"
         });
-      } catch (err) {
-        throw WebinyError.from(err, {
-          message: "Could not create team.",
-          code: "CREATE_TEAM_ERROR",
-          data: {
-            keys
-          }
+    const createTeamGsiKeys = (team)=>({
+            GSI1_PK: `T#${team.tenant}#TEAMS`,
+            GSI1_SK: team.slug,
+            GSI_TENANT: team.tenant,
+            TYPE: "security.team"
         });
-      }
-    },
-    async deleteApiKey({
-      apiKey
-    }) {
-      const keys = createApiKeyKeys(apiKey);
-      try {
-        await entities.apiKeys.delete(keys);
-      } catch (err) {
-        throw WebinyError.from(err, {
-          message: "Could not update api key.",
-          code: "UPDATE_API_KEY_ERROR",
-          data: {
-            keys
-          }
-        });
-      }
-    },
-    async deleteRole({
-      role
-    }) {
-      const keys = createRoleKeys(role);
-      try {
-        await entities.roles.delete(keys);
-      } catch (err) {
-        throw WebinyError.from(err, {
-          message: "Could not delete role.",
-          code: "CREATE_DELETE_ERROR",
-          data: {
-            keys,
-            role
-          }
-        });
-      }
-    },
-    async deleteTeam({
-      team
-    }) {
-      const keys = createTeamKeys(team);
-      try {
-        await entities.teams.delete(keys);
-      } catch (err) {
-        throw WebinyError.from(err, {
-          message: "Could not delete team.",
-          code: "CREATE_DELETE_ERROR",
-          data: {
-            keys,
-            team
-          }
-        });
-      }
-    },
-    async getApiKey({
-      id,
-      tenant
-    }) {
-      const keys = createApiKeyKeys({
-        id,
-        tenant
-      });
-      try {
-        const response = await entities.apiKeys.get(keys);
-        return response?.data || null;
-      } catch (err) {
-        throw WebinyError.from(err, {
-          message: "Could not load api key.",
-          code: "GET_API_KEY_ERROR",
-          data: {
-            id,
-            keys
-          }
-        });
-      }
-    },
-    async getApiKeyByToken({
-      tenant,
-      token
-    }) {
-      const queryParams = {
-        partitionKey: `T#${tenant}#API_KEYS`,
-        options: {
-          eq: token,
-          index: "GSI1"
+    return {
+        async createApiKey ({ apiKey }) {
+            const keys = {
+                ...createApiKeyKeys(apiKey),
+                ...createApiKeyGsiKeys(apiKey)
+            };
+            try {
+                await entities.apiKeys.put({
+                    data: apiKey,
+                    ...keys
+                });
+            } catch (err) {
+                throw error.from(err, {
+                    message: "Could not create api key.",
+                    code: "CREATE_API_KEY_ERROR",
+                    data: {
+                        keys
+                    }
+                });
+            }
+        },
+        async createRole ({ role }) {
+            const keys = {
+                ...createRoleKeys(role),
+                ...createRoleGsiKeys(role)
+            };
+            try {
+                await entities.roles.put({
+                    data: role,
+                    ...keys
+                });
+            } catch (err) {
+                throw error.from(err, {
+                    message: "Could not create role.",
+                    code: "CREATE_ROLE_ERROR",
+                    data: {
+                        keys
+                    }
+                });
+            }
+        },
+        async createTeam ({ team }) {
+            const keys = {
+                ...createTeamKeys(team),
+                ...createTeamGsiKeys(team)
+            };
+            try {
+                await entities.teams.put({
+                    data: team,
+                    ...keys
+                });
+            } catch (err) {
+                throw error.from(err, {
+                    message: "Could not create team.",
+                    code: "CREATE_TEAM_ERROR",
+                    data: {
+                        keys
+                    }
+                });
+            }
+        },
+        async deleteApiKey ({ apiKey }) {
+            const keys = createApiKeyKeys(apiKey);
+            try {
+                await entities.apiKeys.delete(keys);
+            } catch (err) {
+                throw error.from(err, {
+                    message: "Could not update api key.",
+                    code: "UPDATE_API_KEY_ERROR",
+                    data: {
+                        keys
+                    }
+                });
+            }
+        },
+        async deleteRole ({ role }) {
+            const keys = createRoleKeys(role);
+            try {
+                await entities.roles.delete(keys);
+            } catch (err) {
+                throw error.from(err, {
+                    message: "Could not delete role.",
+                    code: "CREATE_DELETE_ERROR",
+                    data: {
+                        keys,
+                        role
+                    }
+                });
+            }
+        },
+        async deleteTeam ({ team }) {
+            const keys = createTeamKeys(team);
+            try {
+                await entities.teams.delete(keys);
+            } catch (err) {
+                throw error.from(err, {
+                    message: "Could not delete team.",
+                    code: "CREATE_DELETE_ERROR",
+                    data: {
+                        keys,
+                        team
+                    }
+                });
+            }
+        },
+        async getApiKey ({ id, tenant }) {
+            const keys = createApiKeyKeys({
+                id,
+                tenant
+            });
+            try {
+                const response = await entities.apiKeys.get(keys);
+                return response?.data || null;
+            } catch (err) {
+                throw error.from(err, {
+                    message: "Could not load api key.",
+                    code: "GET_API_KEY_ERROR",
+                    data: {
+                        id,
+                        keys
+                    }
+                });
+            }
+        },
+        async getApiKeyByToken ({ tenant, token }) {
+            const queryParams = {
+                partitionKey: `T#${tenant}#API_KEYS`,
+                options: {
+                    eq: token,
+                    index: "GSI1"
+                }
+            };
+            try {
+                const result = await entities.apiKeys.queryOne(queryParams);
+                return result?.data || null;
+            } catch (err) {
+                throw error.from(err, {
+                    message: "Could not load api key by token.",
+                    code: "GET_BY_TOKEN_API_KEY_ERROR",
+                    data: {
+                        partitionKey: queryParams.partitionKey,
+                        options: queryParams.options
+                    }
+                });
+            }
+        },
+        async getApiKeyBySlug ({ tenant, slug }) {
+            const queryParams = {
+                partitionKey: `T#${tenant}#API_KEYS`,
+                options: {
+                    eq: slug,
+                    index: "GSI2"
+                }
+            };
+            try {
+                const result = await entities.apiKeys.queryOne(queryParams);
+                return result?.data || null;
+            } catch (err) {
+                throw error.from(err, {
+                    message: "Could not load api key by slug.",
+                    code: "GET_BY_SLUG_API_KEY_ERROR",
+                    data: {
+                        partitionKey: queryParams.partitionKey,
+                        options: queryParams.options
+                    }
+                });
+            }
+        },
+        async getRole ({ where: { tenant, id, slug } }) {
+            try {
+                if (id) {
+                    const result = await entities.roles.get(createRoleKeys({
+                        tenant,
+                        id
+                    }));
+                    return result?.data || null;
+                }
+                const result = await entities.roles.queryOne({
+                    partitionKey: `T#${tenant}#ROLES`,
+                    options: {
+                        index: "GSI1",
+                        eq: slug
+                    }
+                });
+                return result?.data || null;
+            } catch (err) {
+                throw error.from(err, {
+                    message: "Could not load role.",
+                    code: "GET_ROLE_ERROR",
+                    data: {
+                        id,
+                        slug
+                    }
+                });
+            }
+        },
+        async getTeam ({ where: { tenant, id, slug } }) {
+            try {
+                if (id) {
+                    const result = await entities.teams.get(createTeamKeys({
+                        tenant,
+                        id
+                    }));
+                    return result?.data || null;
+                }
+                const result = await entities.teams.queryOne({
+                    partitionKey: `T#${tenant}#TEAMS`,
+                    options: {
+                        index: "GSI1",
+                        eq: slug
+                    }
+                });
+                return result?.data || null;
+            } catch (err) {
+                throw error.from(err, {
+                    message: "Could not load team.",
+                    code: "GET_TEAM_ERROR",
+                    data: {
+                        id,
+                        slug
+                    }
+                });
+            }
+        },
+        async listApiKeys ({ where: { tenant }, sort }) {
+            let items;
+            try {
+                items = await entities.apiKeys.queryAll({
+                    partitionKey: `T#${tenant}#API_KEYS`,
+                    options: {
+                        index: "GSI1"
+                    }
+                });
+            } catch (err) {
+                throw error.from(err, {
+                    message: "Could not list api keys.",
+                    code: "LIST_API_KEY_ERROR"
+                });
+            }
+            return sortItems({
+                items,
+                sort
+            }).map((item)=>item.data);
+        },
+        async listRoles ({ where: { tenant, id_in, slug_in }, sort }) {
+            let items;
+            try {
+                const ddbItems = await entities.roles.queryAll({
+                    partitionKey: `T#${tenant}#ROLES`,
+                    options: {
+                        index: "GSI1"
+                    }
+                });
+                items = ddbItems.map((item)=>item.data);
+            } catch (err) {
+                throw error.from(err, {
+                    message: "Could not list roles.",
+                    code: "LIST_ROLE_ERROR"
+                });
+            }
+            items = sortItems({
+                items,
+                sort
+            });
+            if (Array.isArray(id_in)) return items.filter((item)=>id_in.includes(item.id));
+            if (Array.isArray(slug_in)) return items.filter((item)=>slug_in.includes(item.slug));
+            return items;
+        },
+        async listTeams ({ where: { tenant, id_in, slug_in }, sort }) {
+            let items;
+            try {
+                const ddbRecords = await entities.teams.queryAll({
+                    partitionKey: `T#${tenant}#TEAMS`,
+                    options: {
+                        index: "GSI1"
+                    }
+                });
+                items = ddbRecords.map((item)=>item.data);
+            } catch (err) {
+                throw error.from(err, {
+                    message: "Could not list teams.",
+                    code: "LIST_TEAM_ERROR"
+                });
+            }
+            items = sortItems({
+                items,
+                sort
+            });
+            if (Array.isArray(id_in)) return items.filter((item)=>id_in.includes(item.id));
+            if (Array.isArray(slug_in)) return items.filter((item)=>slug_in.includes(item.slug));
+            return items;
+        },
+        async updateApiKey ({ apiKey }) {
+            const keys = {
+                ...createApiKeyKeys(apiKey),
+                ...createApiKeyGsiKeys(apiKey)
+            };
+            try {
+                await entities.apiKeys.put({
+                    data: apiKey,
+                    ...keys
+                });
+            } catch (err) {
+                throw error.from(err, {
+                    message: "Could not update api key.",
+                    code: "UPDATE_API_KEY_ERROR",
+                    data: {
+                        keys
+                    }
+                });
+            }
+        },
+        async updateRole ({ role }) {
+            const keys = createRoleKeys(role);
+            try {
+                await entities.roles.put({
+                    data: role,
+                    ...keys,
+                    ...createRoleGsiKeys(role)
+                });
+            } catch (err) {
+                throw error.from(err, {
+                    message: "Could not update role.",
+                    code: "UPDATE_ROLE_ERROR",
+                    data: {
+                        keys,
+                        role
+                    }
+                });
+            }
+        },
+        async updateTeam ({ team }) {
+            const keys = createTeamKeys(team);
+            try {
+                await entities.teams.put({
+                    data: team,
+                    ...keys,
+                    ...createTeamGsiKeys(team)
+                });
+            } catch (err) {
+                throw error.from(err, {
+                    message: "Could not update team.",
+                    code: "UPDATE_TEAM_ERROR",
+                    data: {
+                        keys,
+                        team
+                    }
+                });
+            }
         }
-      };
-      try {
-        const result = await entities.apiKeys.queryOne(queryParams);
-        return result?.data || null;
-      } catch (err) {
-        throw WebinyError.from(err, {
-          message: "Could not load api key by token.",
-          code: "GET_BY_TOKEN_API_KEY_ERROR",
-          data: {
-            partitionKey: queryParams.partitionKey,
-            options: queryParams.options
-          }
-        });
-      }
-    },
-    async getApiKeyBySlug({
-      tenant,
-      slug
-    }) {
-      const queryParams = {
-        partitionKey: `T#${tenant}#API_KEYS`,
-        options: {
-          eq: slug,
-          index: "GSI2"
-        }
-      };
-      try {
-        const result = await entities.apiKeys.queryOne(queryParams);
-        return result?.data || null;
-      } catch (err) {
-        throw WebinyError.from(err, {
-          message: "Could not load api key by slug.",
-          code: "GET_BY_SLUG_API_KEY_ERROR",
-          data: {
-            partitionKey: queryParams.partitionKey,
-            options: queryParams.options
-          }
-        });
-      }
-    },
-    async getRole({
-      where: {
-        tenant,
-        id,
-        slug
-      }
-    }) {
-      try {
-        if (id) {
-          const result = await entities.roles.get(createRoleKeys({
-            tenant,
-            id
-          }));
-          return result?.data || null;
-        }
-        const result = await entities.roles.queryOne({
-          partitionKey: `T#${tenant}#ROLES`,
-          options: {
-            index: "GSI1",
-            eq: slug
-          }
-        });
-        return result?.data || null;
-      } catch (err) {
-        throw WebinyError.from(err, {
-          message: "Could not load role.",
-          code: "GET_ROLE_ERROR",
-          data: {
-            id,
-            slug
-          }
-        });
-      }
-    },
-    async getTeam({
-      where: {
-        tenant,
-        id,
-        slug
-      }
-    }) {
-      try {
-        if (id) {
-          const result = await entities.teams.get(createTeamKeys({
-            tenant,
-            id
-          }));
-          return result?.data || null;
-        }
-        const result = await entities.teams.queryOne({
-          partitionKey: `T#${tenant}#TEAMS`,
-          options: {
-            index: "GSI1",
-            eq: slug
-          }
-        });
-        return result?.data || null;
-      } catch (err) {
-        throw WebinyError.from(err, {
-          message: "Could not load team.",
-          code: "GET_TEAM_ERROR",
-          data: {
-            id,
-            slug
-          }
-        });
-      }
-    },
-    async listApiKeys({
-      where: {
-        tenant
-      },
-      sort
-    }) {
-      let items;
-      try {
-        items = await entities.apiKeys.queryAll({
-          partitionKey: `T#${tenant}#API_KEYS`,
-          options: {
-            index: "GSI1"
-          }
-        });
-      } catch (err) {
-        throw WebinyError.from(err, {
-          message: "Could not list api keys.",
-          code: "LIST_API_KEY_ERROR"
-        });
-      }
-      return sortItems({
-        items,
-        sort
-      }).map(item => item.data);
-    },
-    async listRoles({
-      where: {
-        tenant,
-        id_in,
-        slug_in
-      },
-      sort
-    }) {
-      let items;
-      try {
-        const ddbItems = await entities.roles.queryAll({
-          partitionKey: `T#${tenant}#ROLES`,
-          options: {
-            index: "GSI1"
-          }
-        });
-        items = ddbItems.map(item => item.data);
-      } catch (err) {
-        throw WebinyError.from(err, {
-          message: "Could not list roles.",
-          code: "LIST_ROLE_ERROR"
-        });
-      }
-      items = sortItems({
-        items,
-        sort
-      });
-      if (Array.isArray(id_in)) {
-        return items.filter(item => id_in.includes(item.id));
-      }
-      if (Array.isArray(slug_in)) {
-        return items.filter(item => slug_in.includes(item.slug));
-      }
-      return items;
-    },
-    async listTeams({
-      where: {
-        tenant,
-        id_in,
-        slug_in
-      },
-      sort
-    }) {
-      let items;
-      try {
-        const ddbRecords = await entities.teams.queryAll({
-          partitionKey: `T#${tenant}#TEAMS`,
-          options: {
-            index: "GSI1"
-          }
-        });
-        items = ddbRecords.map(item => item.data);
-      } catch (err) {
-        throw WebinyError.from(err, {
-          message: "Could not list teams.",
-          code: "LIST_TEAM_ERROR"
-        });
-      }
-      items = sortItems({
-        items,
-        sort
-      });
-      if (Array.isArray(id_in)) {
-        return items.filter(item => id_in.includes(item.id));
-      }
-      if (Array.isArray(slug_in)) {
-        return items.filter(item => slug_in.includes(item.slug));
-      }
-      return items;
-    },
-    async updateApiKey({
-      apiKey
-    }) {
-      const keys = {
-        ...createApiKeyKeys(apiKey),
-        ...createApiKeyGsiKeys(apiKey)
-      };
-      try {
-        await entities.apiKeys.put({
-          data: apiKey,
-          ...keys
-        });
-      } catch (err) {
-        throw WebinyError.from(err, {
-          message: "Could not update api key.",
-          code: "UPDATE_API_KEY_ERROR",
-          data: {
-            keys
-          }
-        });
-      }
-    },
-    async updateRole({
-      role
-    }) {
-      const keys = createRoleKeys(role);
-      try {
-        await entities.roles.put({
-          data: role,
-          ...keys,
-          ...createRoleGsiKeys(role)
-        });
-      } catch (err) {
-        throw WebinyError.from(err, {
-          message: "Could not update role.",
-          code: "UPDATE_ROLE_ERROR",
-          data: {
-            keys,
-            role
-          }
-        });
-      }
-    },
-    async updateTeam({
-      team
-    }) {
-      const keys = createTeamKeys(team);
-      try {
-        await entities.teams.put({
-          data: team,
-          ...keys,
-          ...createTeamGsiKeys(team)
-        });
-      } catch (err) {
-        throw WebinyError.from(err, {
-          message: "Could not update team.",
-          code: "UPDATE_TEAM_ERROR",
-          data: {
-            keys,
-            team
-          }
-        });
-      }
-    }
-  };
+    };
 };
+export { createStorageOperations };
 
 //# sourceMappingURL=index.js.map