feat: switched up all dal except policy ones

2026-10-17 08:35:52 +00:00 · 2025-10-10 00:09:45 +05:30
parent 4d68d48d89
commit 0ddf98ec15
37 changed files with 1022 additions and 895 deletions
@@ -2,6 +2,7 @@ import { Knex } from "knex";

 import { TDbClient } from "@app/db";
 import {
+  AccessScope,
  TableName,
  TIdentityAlicloudAuths,
  TIdentityAwsAuths,
@@ -11,15 +12,15 @@ import {
  TIdentityKubernetesAuths,
  TIdentityOciAuths,
  TIdentityOidcAuths,
-  TIdentityOrgMemberships,
  TIdentityTlsCertAuths,
  TIdentityTokenAuths,
  TIdentityUniversalAuths,
-  TOrgRoles
+  TMembershipRoles,
+  TMemberships
 } from "@app/db/schemas";
 import { TIdentityLdapAuths } from "@app/db/schemas/identity-ldap-auths";
 import { BadRequestError, DatabaseError } from "@app/lib/errors";
-import { ormify, selectAllTableCols, sqlNestRelationships } from "@app/lib/knex";
+import { selectAllTableCols, sqlNestRelationships } from "@app/lib/knex";
 import { buildKnexFilterForSearchResource } from "@app/lib/search-resource/db";
 import { OrderByDirection } from "@app/lib/types";
 import {
@@ -33,80 +34,80 @@ import { buildAuthMethods } from "./identity-fns";
 export type TIdentityOrgDALFactory = ReturnType<typeof identityOrgDALFactory>;

 export const identityOrgDALFactory = (db: TDbClient) => {
-  const identityOrgOrm = ormify(db, TableName.IdentityOrgMembership);
-
-  const findOne = async (filter: Partial<TIdentityOrgMemberships>, tx?: Knex) => {
+  const findOne = async (filter: Partial<TMemberships>, tx?: Knex) => {
    try {
-      const [data] = await (tx || db.replicaNode())(TableName.IdentityOrgMembership)
+      const [data] = await (tx || db.replicaNode())(TableName.Membership)
+        .where(`${TableName.Membership}.scope`, AccessScope.Organization)
+        .whereNotNull(`${TableName.Membership}.actorIdentityId`)
        .where((queryBuilder) => {
          Object.entries(filter).forEach(([key, value]) => {
-            void queryBuilder.where(`${TableName.IdentityOrgMembership}.${key}`, value);
+            void queryBuilder.where(`${TableName.Membership}.${key}`, value);
          });
        })
-        .join(TableName.Identity, `${TableName.IdentityOrgMembership}.identityId`, `${TableName.Identity}.id`)
+        .join(TableName.Identity, `${TableName.Membership}.actorIdentityId`, `${TableName.Identity}.id`)

        .leftJoin<TIdentityUniversalAuths>(
          TableName.IdentityUniversalAuth,
-          `${TableName.IdentityOrgMembership}.identityId`,
+          `${TableName.Membership}.actorIdentityId`,
          `${TableName.IdentityUniversalAuth}.identityId`
        )
        .leftJoin<TIdentityGcpAuths>(
          TableName.IdentityGcpAuth,
-          `${TableName.IdentityOrgMembership}.identityId`,
+          `${TableName.Membership}.actorIdentityId`,
          `${TableName.IdentityGcpAuth}.identityId`
        )
        .leftJoin<TIdentityAlicloudAuths>(
          TableName.IdentityAliCloudAuth,
-          `${TableName.IdentityOrgMembership}.identityId`,
+          `${TableName.Membership}.actorIdentityId`,
          `${TableName.IdentityAliCloudAuth}.identityId`
        )
        .leftJoin<TIdentityAwsAuths>(
          TableName.IdentityAwsAuth,
-          `${TableName.IdentityOrgMembership}.identityId`,
+          `${TableName.Membership}.actorIdentityId`,
          `${TableName.IdentityAwsAuth}.identityId`
        )
        .leftJoin<TIdentityKubernetesAuths>(
          TableName.IdentityKubernetesAuth,
-          `${TableName.IdentityOrgMembership}.identityId`,
+          `${TableName.Membership}.actorIdentityId`,
          `${TableName.IdentityKubernetesAuth}.identityId`
        )
        .leftJoin<TIdentityOciAuths>(
          TableName.IdentityOciAuth,
-          `${TableName.IdentityOrgMembership}.identityId`,
+          `${TableName.Membership}.actorIdentityId`,
          `${TableName.IdentityOciAuth}.identityId`
        )
        .leftJoin<TIdentityOidcAuths>(
          TableName.IdentityOidcAuth,
-          `${TableName.IdentityOrgMembership}.identityId`,
+          `${TableName.Membership}.actorIdentityId`,
          `${TableName.IdentityOidcAuth}.identityId`
        )
        .leftJoin<TIdentityAzureAuths>(
          TableName.IdentityAzureAuth,
-          `${TableName.IdentityOrgMembership}.identityId`,
+          `${TableName.Membership}.actorIdentityId`,
          `${TableName.IdentityAzureAuth}.identityId`
        )
        .leftJoin<TIdentityTokenAuths>(
          TableName.IdentityTokenAuth,
-          `${TableName.IdentityOrgMembership}.identityId`,
+          `${TableName.Membership}.actorIdentityId`,
          `${TableName.IdentityTokenAuth}.identityId`
        )
        .leftJoin<TIdentityJwtAuths>(
          TableName.IdentityJwtAuth,
-          `${TableName.IdentityOrgMembership}.identityId`,
+          `${TableName.Membership}.actorIdentityId`,
          `${TableName.IdentityJwtAuth}.identityId`
        )
        .leftJoin<TIdentityLdapAuths>(
          TableName.IdentityLdapAuth,
-          `${TableName.IdentityOrgMembership}.identityId`,
+          `${TableName.Membership}.actorIdentityId`,
          `${TableName.IdentityLdapAuth}.identityId`
        )
        .leftJoin<TIdentityTlsCertAuths>(
          TableName.IdentityTlsCertAuth,
-          `${TableName.IdentityOrgMembership}.identityId`,
+          `${TableName.Membership}.actorIdentityId`,
          `${TableName.IdentityTlsCertAuth}.identityId`
        )
        .select(
-          selectAllTableCols(TableName.IdentityOrgMembership),
+          selectAllTableCols(TableName.Membership),

          db.ref("id").as("uaId").withSchema(TableName.IdentityUniversalAuth),
          db.ref("id").as("gcpId").withSchema(TableName.IdentityGcpAuth),
@@ -129,7 +130,7 @@ export const identityOrgDALFactory = (db: TDbClient) => {
        return {
          ...data,
          identity: {
-            id: data.identityId,
+            id: data.actorIdentityId as string,
            name,
            hasDeleteProtection,
            authMethods: buildAuthMethods(data)
@@ -149,20 +150,18 @@ export const identityOrgDALFactory = (db: TDbClient) => {
      orderDirection = OrderByDirection.ASC,
      search,
      ...filter
-    }: Partial<TIdentityOrgMemberships> &
+    }: Partial<TMemberships> &
      Pick<TListOrgIdentitiesByOrgIdDTO, "offset" | "limit" | "orderBy" | "orderDirection" | "search">,
    tx?: Knex
  ) => {
    try {
      const paginatedIdentity = (tx || db.replicaNode())(TableName.Identity)
-        .join(
-          TableName.IdentityOrgMembership,
-          `${TableName.IdentityOrgMembership}.identityId`,
-          `${TableName.Identity}.id`
-        )
+        .join(TableName.Membership, `${TableName.Membership}.actorIdentityId`, `${TableName.Identity}.id`)
+        .where(`${TableName.Membership}.scope`, AccessScope.Organization)
+        .whereNotNull(`${TableName.Membership}.actorIdentityId`)
        .orderBy(`${TableName.Identity}.${orderBy}`, orderDirection)
        .select(
-          selectAllTableCols(TableName.IdentityOrgMembership),
+          selectAllTableCols(TableName.Membership),
          db.ref("name").withSchema(TableName.Identity).as("identityName"),
          db.ref("hasDeleteProtection").withSchema(TableName.Identity)
        )
@@ -181,14 +180,17 @@ export const identityOrgDALFactory = (db: TDbClient) => {
      type TSubquery = Awaited<typeof paginatedIdentity>;
      const query = (tx || db.replicaNode())
        .from<TSubquery[number], TSubquery>(paginatedIdentity)
-        .leftJoin<TOrgRoles>(TableName.OrgRoles, `paginatedIdentity.roleId`, `${TableName.OrgRoles}.id`)
-
+        .join<TMembershipRoles>(
+          TableName.MembershipRole,
+          `${TableName.MembershipRole}.membershipId`,
+          "paginatedIdentity.id"
+        )
+        .leftJoin(TableName.Role, `${TableName.MembershipRole}.customRoleId`, `${TableName.Role}.id`)
        .leftJoin(TableName.IdentityMetadata, (queryBuilder) => {
          void queryBuilder
-            .on(`paginatedIdentity.identityId`, `${TableName.IdentityMetadata}.identityId`)
-            .andOn(`paginatedIdentity.orgId`, `${TableName.IdentityMetadata}.orgId`);
+            .on(`paginatedIdentity.actorIdentityId`, `${TableName.IdentityMetadata}.identityId`)
+            .andOn(`paginatedIdentity.scopeOrgId`, `${TableName.IdentityMetadata}.orgId`);
        })
-
        .leftJoin<TIdentityUniversalAuths>(
          TableName.IdentityUniversalAuth,
          "paginatedIdentity.identityId",
@@ -251,14 +253,14 @@ export const identityOrgDALFactory = (db: TDbClient) => {
        )
        .select(
          db.ref("id").withSchema("paginatedIdentity"),
-          db.ref("role").withSchema("paginatedIdentity"),
-          db.ref("roleId").withSchema("paginatedIdentity"),
-          db.ref("orgId").withSchema("paginatedIdentity"),
+          db.ref("role").withSchema(TableName.MembershipRole),
+          db.ref("customRoleId").withSchema(TableName.MembershipRole).as("roleId"),
+          db.ref("scopeOrgId").withSchema("paginatedIdentity").as("orgId"),
          db.ref("lastLoginAuthMethod").withSchema("paginatedIdentity"),
          db.ref("lastLoginTime").withSchema("paginatedIdentity"),
          db.ref("createdAt").withSchema("paginatedIdentity"),
          db.ref("updatedAt").withSchema("paginatedIdentity"),
-          db.ref("identityId").withSchema("paginatedIdentity").as("identityId"),
+          db.ref("actorIdentityId").withSchema("paginatedIdentity").as("identityId"),
          db.ref("identityName").withSchema("paginatedIdentity"),
          db.ref("hasDeleteProtection").withSchema("paginatedIdentity"),

@@ -276,12 +278,11 @@ export const identityOrgDALFactory = (db: TDbClient) => {
          db.ref("id").as("tlsCertId").withSchema(TableName.IdentityTlsCertAuth)
        )
        // cr stands for custom role
-        .select(db.ref("id").as("crId").withSchema(TableName.OrgRoles))
-        .select(db.ref("name").as("crName").withSchema(TableName.OrgRoles))
-        .select(db.ref("slug").as("crSlug").withSchema(TableName.OrgRoles))
-        .select(db.ref("description").as("crDescription").withSchema(TableName.OrgRoles))
-        .select(db.ref("permissions").as("crPermission").withSchema(TableName.OrgRoles))
-        .select(db.ref("permissions").as("crPermission").withSchema(TableName.OrgRoles))
+        .select(db.ref("id").as("crId").withSchema(TableName.Role))
+        .select(db.ref("name").as("crName").withSchema(TableName.Role))
+        .select(db.ref("slug").as("crSlug").withSchema(TableName.Role))
+        .select(db.ref("description").as("crDescription").withSchema(TableName.Role))
+        .select(db.ref("permissions").as("crPermission").withSchema(TableName.Role))
        .select(
          db.ref("id").withSchema(TableName.IdentityMetadata).as("metadataId"),
          db.ref("key").withSchema(TableName.IdentityMetadata).as("metadataKey"),
@@ -327,7 +328,7 @@ export const identityOrgDALFactory = (db: TDbClient) => {
        }) => ({
          role,
          roleId,
-          identityId,
+          identityId: identityId as string,
          id,
          orgId,
          createdAt,
@@ -344,7 +345,7 @@ export const identityOrgDALFactory = (db: TDbClient) => {
              }
            : undefined,
          identity: {
-            id: identityId,
+            id: identityId as string,
            name: identityName,
            hasDeleteProtection,
            authMethods: buildAuthMethods({
@@ -394,20 +395,23 @@ export const identityOrgDALFactory = (db: TDbClient) => {
    tx?: Knex
  ) => {
    try {
-      const searchQuery = (tx || db.replicaNode())(TableName.IdentityOrgMembership)
-        .join(TableName.Identity, `${TableName.Identity}.id`, `${TableName.IdentityOrgMembership}.identityId`)
-        .where(`${TableName.IdentityOrgMembership}.orgId`, orgId)
-        .leftJoin(TableName.OrgRoles, `${TableName.IdentityOrgMembership}.roleId`, `${TableName.OrgRoles}.id`)
+      const searchQuery = (tx || db.replicaNode())(TableName.Membership)
+        .where(`${TableName.Membership}.scope`, AccessScope.Organization)
+        .whereNotNull(`${TableName.Membership}.actorIdentityId`)
+        .where(`${TableName.Membership}.scopeOrgId`, orgId)
+        .join(TableName.Identity, `${TableName.Identity}.id`, `${TableName.Membership}.actorIdentityId`)
+        .join(TableName.MembershipRole, `${TableName.MembershipRole}.membershipId`, `${TableName.Membership}.id`)
+        .leftJoin(TableName.Role, `${TableName.MembershipRole}.customRoleId`, `${TableName.Role}.id`)
        .orderBy(
          orderBy === OrgIdentityOrderBy.Role
-            ? `${TableName.IdentityOrgMembership}.${orderBy}`
+            ? `${TableName.Membership}.${orderBy}`
            : `${TableName.Identity}.${orderBy}`,
          orderDirection
        )
-        .select(`${TableName.IdentityOrgMembership}.id`)
+        .select(`${TableName.Membership}.id`)
        .select<{ id: string; total_count: string }>(
          db.raw(
-            `count(${TableName.IdentityOrgMembership}."identityId") OVER(PARTITION BY ${TableName.IdentityOrgMembership}."orgId") as total_count`
+            `count(${TableName.Membership}."actorIdentityId") OVER(PARTITION BY ${TableName.Membership}."scopeOrgId") as total_count`
          )
        )
        .as("searchedIdentities");
@@ -416,7 +420,7 @@ export const identityOrgDALFactory = (db: TDbClient) => {
        buildKnexFilterForSearchResource(searchQuery, searchFilter, (attr) => {
          switch (attr) {
            case "role":
-              return [`${TableName.OrgRoles}.slug`, `${TableName.IdentityOrgMembership}.role`];
+              return [`${TableName.Role}.slug`, `${TableName.MembershipRole}.role`];
            case "name":
              return `${TableName.Identity}.name`;
            default:
@@ -430,82 +434,85 @@ export const identityOrgDALFactory = (db: TDbClient) => {
      }

      type TSubquery = Awaited<typeof searchQuery>;
-      const query = (tx || db.replicaNode())(TableName.IdentityOrgMembership)
-        .where(`${TableName.IdentityOrgMembership}.orgId`, orgId)
-        .join<TSubquery>(searchQuery, `${TableName.IdentityOrgMembership}.id`, "searchedIdentities.id")
-        .join(TableName.Identity, `${TableName.IdentityOrgMembership}.identityId`, `${TableName.Identity}.id`)
-        .leftJoin(TableName.OrgRoles, `${TableName.IdentityOrgMembership}.roleId`, `${TableName.OrgRoles}.id`)
+      const query = (tx || db.replicaNode())(TableName.Membership)
+        .where(`${TableName.Membership}.scope`, AccessScope.Organization)
+        .whereNotNull(`${TableName.Membership}.actorIdentityId`)
+        .where(`${TableName.Membership}.scopeOrgId`, orgId)
+        .join<TSubquery>(searchQuery, `${TableName.Membership}.id`, "searchedIdentities.id")
+        .join(TableName.Identity, `${TableName.Membership}.actorIdentityId`, `${TableName.Identity}.id`)
+        .join(TableName.MembershipRole, `${TableName.MembershipRole}.membershipId`, `${TableName.Membership}.id`)
+        .leftJoin(TableName.Role, `${TableName.MembershipRole}.customRoleId`, `${TableName.Role}.id`)
        .leftJoin(TableName.IdentityMetadata, (queryBuilder) => {
          void queryBuilder
-            .on(`${TableName.IdentityOrgMembership}.identityId`, `${TableName.IdentityMetadata}.identityId`)
-            .andOn(`${TableName.IdentityOrgMembership}.orgId`, `${TableName.IdentityMetadata}.orgId`);
+            .on(`${TableName.Membership}.actorIdentityId`, `${TableName.IdentityMetadata}.identityId`)
+            .andOn(`${TableName.Membership}.scopeOrgId`, `${TableName.IdentityMetadata}.orgId`);
        })
        .leftJoin(
          TableName.IdentityUniversalAuth,
-          `${TableName.IdentityOrgMembership}.identityId`,
+          `${TableName.Membership}.actorIdentityId`,
          `${TableName.IdentityUniversalAuth}.identityId`
        )
        .leftJoin(
          TableName.IdentityGcpAuth,
-          `${TableName.IdentityOrgMembership}.identityId`,
+          `${TableName.Membership}.actorIdentityId`,
          `${TableName.IdentityGcpAuth}.identityId`
        )
        .leftJoin(
          TableName.IdentityAliCloudAuth,
-          `${TableName.IdentityOrgMembership}.identityId`,
+          `${TableName.Membership}.actorIdentityId`,
          `${TableName.IdentityAliCloudAuth}.identityId`
        )
        .leftJoin(
          TableName.IdentityAwsAuth,
-          `${TableName.IdentityOrgMembership}.identityId`,
+          `${TableName.Membership}.actorIdentityId`,
          `${TableName.IdentityAwsAuth}.identityId`
        )
        .leftJoin(
          TableName.IdentityKubernetesAuth,
-          `${TableName.IdentityOrgMembership}.identityId`,
+          `${TableName.Membership}.actorIdentityId`,
          `${TableName.IdentityKubernetesAuth}.identityId`
        )
        .leftJoin(
          TableName.IdentityOciAuth,
-          `${TableName.IdentityOrgMembership}.identityId`,
+          `${TableName.Membership}.actorIdentityId`,
          `${TableName.IdentityOciAuth}.identityId`
        )
        .leftJoin(
          TableName.IdentityOidcAuth,
-          `${TableName.IdentityOrgMembership}.identityId`,
+          `${TableName.Membership}.actorIdentityId`,
          `${TableName.IdentityOidcAuth}.identityId`
        )
        .leftJoin(
          TableName.IdentityAzureAuth,
-          `${TableName.IdentityOrgMembership}.identityId`,
+          `${TableName.Membership}.actorIdentityId`,
          `${TableName.IdentityAzureAuth}.identityId`
        )
        .leftJoin(
          TableName.IdentityTokenAuth,
-          `${TableName.IdentityOrgMembership}.identityId`,
+          `${TableName.Membership}.actorIdentityId`,
          `${TableName.IdentityTokenAuth}.identityId`
        )
        .leftJoin(
          TableName.IdentityJwtAuth,
-          `${TableName.IdentityOrgMembership}.identityId`,
+          `${TableName.Membership}.actorIdentityId`,
          `${TableName.IdentityJwtAuth}.identityId`
        )
        .leftJoin(
          TableName.IdentityLdapAuth,
-          `${TableName.IdentityOrgMembership}.identityId`,
+          `${TableName.Membership}.actorIdentityId`,
          `${TableName.IdentityLdapAuth}.identityId`
        )
        .select(
-          db.ref("id").withSchema(TableName.IdentityOrgMembership),
+          db.ref("id").withSchema(TableName.Membership),
          db.ref("total_count").withSchema("searchedIdentities"),
-          db.ref("role").withSchema(TableName.IdentityOrgMembership),
-          db.ref("roleId").withSchema(TableName.IdentityOrgMembership),
-          db.ref("orgId").withSchema(TableName.IdentityOrgMembership),
-          db.ref("createdAt").withSchema(TableName.IdentityOrgMembership),
-          db.ref("updatedAt").withSchema(TableName.IdentityOrgMembership),
-          db.ref("lastLoginAuthMethod").withSchema(TableName.IdentityOrgMembership),
-          db.ref("lastLoginTime").withSchema(TableName.IdentityOrgMembership),
-          db.ref("identityId").withSchema(TableName.IdentityOrgMembership).as("identityId"),
+          db.ref("role").withSchema(TableName.MembershipRole),
+          db.ref("customRoleId").withSchema(TableName.MembershipRole).as("roleId"),
+          db.ref("scopeOrgId").withSchema(TableName.Membership).as("orgId"),
+          db.ref("createdAt").withSchema(TableName.Membership),
+          db.ref("updatedAt").withSchema(TableName.Membership),
+          db.ref("lastLoginAuthMethod").withSchema(TableName.Membership),
+          db.ref("lastLoginTime").withSchema(TableName.Membership),
+          db.ref("actorIdentityId").withSchema(TableName.Membership).as("identityId"),
          db.ref("name").withSchema(TableName.Identity).as("identityName"),
          db.ref("hasDeleteProtection").withSchema(TableName.Identity),

@@ -522,12 +529,11 @@ export const identityOrgDALFactory = (db: TDbClient) => {
          db.ref("id").as("ldapId").withSchema(TableName.IdentityLdapAuth)
        )
        // cr stands for custom role
-        .select(db.ref("id").as("crId").withSchema(TableName.OrgRoles))
-        .select(db.ref("name").as("crName").withSchema(TableName.OrgRoles))
-        .select(db.ref("slug").as("crSlug").withSchema(TableName.OrgRoles))
-        .select(db.ref("description").as("crDescription").withSchema(TableName.OrgRoles))
-        .select(db.ref("permissions").as("crPermission").withSchema(TableName.OrgRoles))
-        .select(db.ref("permissions").as("crPermission").withSchema(TableName.OrgRoles))
+        .select(db.ref("id").as("crId").withSchema(TableName.Role))
+        .select(db.ref("name").as("crName").withSchema(TableName.Role))
+        .select(db.ref("slug").as("crSlug").withSchema(TableName.Role))
+        .select(db.ref("description").as("crDescription").withSchema(TableName.Role))
+        .select(db.ref("permissions").as("crPermission").withSchema(TableName.Role))
        .select(
          db.ref("id").withSchema(TableName.IdentityMetadata).as("metadataId"),
          db.ref("key").withSchema(TableName.IdentityMetadata).as("metadataKey"),
@@ -545,13 +551,7 @@ export const identityOrgDALFactory = (db: TDbClient) => {
            ELSE ??.role
          END ?
          `,
-          [
-            TableName.IdentityOrgMembership,
-            "custom",
-            TableName.OrgRoles,
-            TableName.IdentityOrgMembership,
-            db.raw(orderDirection)
-          ]
+          [TableName.MembershipRole, "custom", TableName.Role, TableName.MembershipRole, db.raw(orderDirection)]
        );
      }

@@ -590,7 +590,7 @@ export const identityOrgDALFactory = (db: TDbClient) => {
        }) => ({
          role,
          roleId,
-          identityId,
+          identityId: identityId as string,
          id,
          total_count: total_count as string,
          orgId,
@@ -646,13 +646,15 @@ export const identityOrgDALFactory = (db: TDbClient) => {
  };

  const countAllOrgIdentities = async (
-    { search, ...filter }: Partial<TIdentityOrgMemberships> & Pick<TListOrgIdentitiesByOrgIdDTO, "search">,
+    { search, ...filter }: Partial<TMemberships> & Pick<TListOrgIdentitiesByOrgIdDTO, "search">,
    tx?: Knex
  ) => {
    try {
-      const query = (tx || db.replicaNode())(TableName.IdentityOrgMembership)
+      const query = (tx || db.replicaNode())(TableName.Membership)
+        .where(`${TableName.Membership}.scope`, AccessScope.Organization)
+        .whereNotNull(`${TableName.Membership}.actorIdentityId`)
        .where(filter)
-        .join(TableName.Identity, `${TableName.IdentityOrgMembership}.identityId`, `${TableName.Identity}.id`)
+        .join(TableName.Identity, `${TableName.Membership}.actorIdentityId`, `${TableName.Identity}.id`)
        .count();

      if (search?.length) {
@@ -667,5 +669,5 @@ export const identityOrgDALFactory = (db: TDbClient) => {
    }
  };

-  return { ...identityOrgOrm, find, findOne, countAllOrgIdentities, searchIdentities };
+  return { find, findOne, countAllOrgIdentities, searchIdentities };
 };