feat: completed migration for membership simplification

backend/src/db/migrations/20251005152640_simplify-membership.ts

@@ -3,9 +3,7 @@ import { Knex } from "knex";
 import { AccessScope, TableName } from "../schemas";
 import { createOnUpdateTrigger, dropOnUpdateTrigger } from "../utils";
 
-export async function up(knex: Knex): Promise<void> {
+const createNamespaceTable = async (knex: Knex) => {
-  const hasNamespaceTable = await knex.schema.hasTable(TableName.Namespace);
-  if (!hasNamespaceTable) {
   await knex.schema.createTable(TableName.Namespace, (t) => {
     t.uuid("id").primary().defaultTo(knex.fn.uuid());
     t.string("name").notNullable();
@@ -16,10 +14,9 @@ export async function up(knex: Knex): Promise<void> {
   });
 
   await createOnUpdateTrigger(knex, TableName.Namespace);
-  }
+};
 
-  const hasMembershipTable = await knex.schema.hasTable(TableName.Membership);
+const createMembershipTable = async (knex: Knex) => {
-  if (!hasMembershipTable) {
   await knex.schema.createTable(TableName.Membership, (t) => {
     t.uuid("id").primary().defaultTo(knex.fn.uuid());
     t.string("scope", 24).notNullable();
@@ -76,10 +73,9 @@ export async function up(knex: Knex): Promise<void> {
   });
 
   await createOnUpdateTrigger(knex, TableName.Membership);
-  }
+};
 
-  const hasRoleTable = await knex.schema.hasTable(TableName.Role);
+const createRoleTable = async (knex: Knex) => {
-  if (!hasRoleTable) {
   await knex.schema.createTable(TableName.Role, (t) => {
     t.uuid("id").primary().defaultTo(knex.fn.uuid());
     t.string("name").notNullable();
@@ -128,10 +124,9 @@ export async function up(knex: Knex): Promise<void> {
   `);
 
   await createOnUpdateTrigger(knex, TableName.Role);
-  }
+};
 
-  const hasMembershipRoleTable = await knex.schema.hasTable(TableName.MembershipRole);
+const createMembershipRoleTable = async (knex: Knex) => {
-  if (!hasMembershipRoleTable) {
   await knex.schema.createTable(TableName.MembershipRole, (t) => {
     t.uuid("id").primary().defaultTo(knex.fn.uuid());
     t.string("role").notNullable();
@@ -152,10 +147,9 @@ export async function up(knex: Knex): Promise<void> {
   });
 
   await createOnUpdateTrigger(knex, TableName.MembershipRole);
-  }
+};
 
-  const hasAdditionalPrivilegeTable = await knex.schema.hasTable(TableName.AdditionalPrivilege);
+const createAdditionalPrivilegeTable = async (knex: Knex) => {
-  if (!hasAdditionalPrivilegeTable) {
   await knex.schema.createTable(TableName.AdditionalPrivilege, (t) => {
     t.uuid("id", { primaryKey: true }).defaultTo(knex.fn.uuid());
     t.string("name", 60).notNullable();
@@ -204,32 +198,516 @@ export async function up(knex: Knex): Promise<void> {
   });
 
   await createOnUpdateTrigger(knex, TableName.AdditionalPrivilege);
-  }
+};
 
-  // no mean this has been created before
+const migrateMembershipData = async (knex: Knex) => {
-  if (!hasMembershipTable) {
+  await knex
-    await knex(TableName.Membership).insert(
+    .insert(
-      // @ts-expect-error never mind
       knex(TableName.OrgMembership).select(
         "id",
         "status",
         "inviteEmail",
         "createdAt",
         "updatedAt",
-        "userId as actorUserId",
+        "userId",
-        "orgId as scopeOrgId",
+        "orgId",
         "projectFavorites",
         "isActive",
         "lastInvitedAt",
         "lastLoginAuthMethod",
         "lastLoginTime",
-        knex.raw("? as scope", [AccessScope.Organization])
+        knex.raw("?", [AccessScope.Organization])
       )
+    )
+    .into(
+      knex.raw("?? (??, ??, ??, ??, ??, ??, ??, ??, ??, ??, ??, ??, ??)", [
+        TableName.Membership,
+        "id",
+        "status",
+        "inviteEmail",
+        "createdAt",
+        "updatedAt",
+        "actorUserId",
+        "scopeOrgId",
+        "projectFavorites",
+        "isActive",
+        "lastInvitedAt",
+        "lastLoginAuthMethod",
+        "lastLoginTime",
+        "scope"
+      ])
     );
+
+  await knex
+    .insert(
+      knex(TableName.IdentityOrgMembership).select(
+        "id",
+        "identityId",
+        "orgId",
+        "lastLoginAuthMethod",
+        "lastLoginTime",
+        "createdAt",
+        "updatedAt",
+        knex.raw("?", [AccessScope.Organization])
+      )
+    )
+    .into(
+      knex.raw("?? (??, ??, ??, ??, ??, ??, ??, ??)", [
+        TableName.Membership,
+        "id",
+        "actorIdentityId",
+        "scopeOrgId",
+        "lastLoginAuthMethod",
+        "lastLoginTime",
+        "createdAt",
+        "updatedAt",
+        "scope"
+      ])
+    );
+
+  await knex
+    .insert(
+      knex(TableName.Groups).select("id", "orgId", "createdAt", "updatedAt", knex.raw("?", [AccessScope.Organization]))
+    )
+    .into(
+      knex.raw("?? (??, ??, ??, ??, ??)", [
+        TableName.Membership,
+        "actorGroupId",
+        "scopeOrgId",
+        "createdAt",
+        "updatedAt",
+        "scope"
+      ])
+    );
+
+  await knex
+    .insert(
+      knex(TableName.ProjectMembership)
+        .join(TableName.Project, `${TableName.ProjectMembership}.projectId`, `${TableName.Project}.id`)
+        .select(
+          knex.ref("id").withSchema(TableName.ProjectMembership),
+          "userId",
+          "projectId",
+          "orgId",
+          knex.ref("createdAt").withSchema(TableName.ProjectMembership),
+          knex.ref("updatedAt").withSchema(TableName.ProjectMembership),
+          knex.raw("?", [AccessScope.Project])
+        )
+    )
+    .into(
+      knex.raw("?? (??, ??, ??, ??, ??, ??, ??)", [
+        TableName.Membership,
+        "id",
+        "actorUserId",
+        "scopeProjectId",
+        "scopeOrgId",
+        "createdAt",
+        "updatedAt",
+        "scope"
+      ])
+    );
+
+  await knex
+    .insert(
+      knex(TableName.IdentityProjectMembership)
+        .join(TableName.Project, `${TableName.IdentityProjectMembership}.projectId`, `${TableName.Project}.id`)
+        .select(
+          knex.ref("id").withSchema(TableName.IdentityProjectMembership),
+          "identityId",
+          "projectId",
+          "orgId",
+          knex.ref("createdAt").withSchema(TableName.IdentityProjectMembership),
+          knex.ref("updatedAt").withSchema(TableName.IdentityProjectMembership),
+          knex.raw("?", [AccessScope.Project])
+        )
+    )
+    .into(
+      knex.raw("?? (??, ??, ??, ??, ??, ??, ??)", [
+        TableName.Membership,
+        "id",
+        "actorIdentityId",
+        "scopeProjectId",
+        "scopeOrgId",
+        "createdAt",
+        "updatedAt",
+        "scope"
+      ])
+    );
+
+  await knex
+    .insert(
+      knex(TableName.GroupProjectMembership)
+        .join(TableName.Project, `${TableName.GroupProjectMembership}.projectId`, `${TableName.Project}.id`)
+        .select(
+          knex.ref("id").withSchema(TableName.GroupProjectMembership),
+          "groupId",
+          "projectId",
+          "orgId",
+          knex.ref("createdAt").withSchema(TableName.GroupProjectMembership),
+          knex.ref("updatedAt").withSchema(TableName.GroupProjectMembership),
+          knex.raw("?", [AccessScope.Project])
+        )
+    )
+    .into(
+      knex.raw("?? (??, ??, ??, ??, ??, ??, ??)", [
+        TableName.Membership,
+        "id",
+        "actorGroupId",
+        "scopeProjectId",
+        "scopeOrgId",
+        "createdAt",
+        "updatedAt",
+        "scope"
+      ])
+    );
+};
+
+const migrateRoleData = async (knex: Knex) => {
+  await knex
+    .insert(
+      knex(TableName.OrgRoles).select(
+        "id",
+        "name",
+        "description",
+        "slug",
+        "permissions",
+        "createdAt",
+        "updatedAt",
+        "orgId"
+      )
+    )
+    .into(
+      knex.raw("?? (??, ??, ??, ??, ??, ??, ??, ??)", [
+        TableName.Role,
+        "id",
+        "name",
+        "description",
+        "slug",
+        "permissions",
+        "createdAt",
+        "updatedAt",
+        "orgId"
+      ])
+    );
+
+  await knex
+    .insert(
+      knex(TableName.ProjectRoles).select(
+        "id",
+        "name",
+        "description",
+        "slug",
+        "permissions",
+        "createdAt",
+        "updatedAt",
+        "projectId"
+      )
+    )
+    .into(
+      knex.raw("?? (??, ??, ??, ??, ??, ??, ??, ??)", [
+        TableName.Role,
+        "id",
+        "name",
+        "description",
+        "slug",
+        "permissions",
+        "createdAt",
+        "updatedAt",
+        "projectId"
+      ])
+    );
+
+  const hasExternalGroupRoleMappingRoleColumn = await knex.schema.hasColumn(
+    TableName.ExternalGroupOrgRoleMapping,
+    "roleId"
+  );
+  if (hasExternalGroupRoleMappingRoleColumn) {
+    await knex.schema.alterTable(TableName.ExternalGroupOrgRoleMapping, (t) => {
+      t.dropForeign("roleId");
+      t.foreign("roleId").references("id").inTable(TableName.Role);
+    });
+  }
+};
+
+const migrateMembershipRoleData = async (knex: Knex) => {
+  await knex
+    .insert(knex(TableName.OrgMembership).select("id", "role", "roleId"))
+    .into(knex.raw("?? (??, ??, ??)", [TableName.MembershipRole, "membershipId", "role", "customRoleId"]));
+
+  await knex
+    .insert(knex(TableName.IdentityOrgMembership).select("id", "role", "roleId"))
+    .into(knex.raw("?? (??, ??, ??)", [TableName.MembershipRole, "membershipId", "role", "customRoleId"]));
+
+  await knex
+    .insert(
+      knex(TableName.Groups)
+        .join(TableName.Membership, (qb) => {
+          qb.on(`${TableName.Groups}.id`, `${TableName.Membership}.actorGroupId`)
+            .andOn(`${TableName.Groups}.orgId`, `${TableName.Membership}.scopeOrgId`)
+            .andOn(`${TableName.Membership}.scope`, knex.raw("?", [AccessScope.Organization]));
+        })
+        .select(knex.ref("id").withSchema(TableName.Membership), "role", "roleId")
+    )
+    .into(knex.raw("?? (??, ??, ??)", [TableName.MembershipRole, "membershipId", "role", "customRoleId"]));
+
+  await knex
+    .insert(
+      knex(TableName.ProjectUserMembershipRole).select(
+        "id",
+        "role",
+        "projectMembershipId",
+        "customRoleId",
+        "isTemporary",
+        "temporaryMode",
+        "temporaryRange",
+        "temporaryAccessStartTime",
+        "temporaryAccessEndTime",
+        "createdAt",
+        "updatedAt"
+      )
+    )
+    .into(
+      knex.raw("?? (??,??,??,??,??,??,??,??,??,??,??)", [
+        TableName.MembershipRole,
+        "id",
+        "role",
+        "membershipId",
+        "customRoleId",
+        "isTemporary",
+        "temporaryMode",
+        "temporaryRange",
+        "temporaryAccessStartTime",
+        "temporaryAccessEndTime",
+        "createdAt",
+        "updatedAt"
+      ])
+    );
+
+  await knex
+    .insert(
+      knex(TableName.IdentityProjectMembershipRole).select(
+        "id",
+        "role",
+        "projectMembershipId",
+        "customRoleId",
+        "isTemporary",
+        "temporaryMode",
+        "temporaryRange",
+        "temporaryAccessStartTime",
+        "temporaryAccessEndTime",
+        "createdAt",
+        "updatedAt"
+      )
+    )
+    .into(
+      knex.raw("?? (??,??,??,??,??,??,??,??,??,??,??)", [
+        TableName.MembershipRole,
+        "id",
+        "role",
+        "membershipId",
+        "customRoleId",
+        "isTemporary",
+        "temporaryMode",
+        "temporaryRange",
+        "temporaryAccessStartTime",
+        "temporaryAccessEndTime",
+        "createdAt",
+        "updatedAt"
+      ])
+    );
+
+  await knex
+    .insert(
+      knex(TableName.GroupProjectMembershipRole).select(
+        "id",
+        "role",
+        "projectMembershipId",
+        "customRoleId",
+        "isTemporary",
+        "temporaryMode",
+        "temporaryRange",
+        "temporaryAccessStartTime",
+        "temporaryAccessEndTime",
+        "createdAt",
+        "updatedAt"
+      )
+    )
+    .into(
+      knex.raw("?? (??,??,??,??,??,??,??,??,??,??,??)", [
+        TableName.MembershipRole,
+        "id",
+        "role",
+        "membershipId",
+        "customRoleId",
+        "isTemporary",
+        "temporaryMode",
+        "temporaryRange",
+        "temporaryAccessStartTime",
+        "temporaryAccessEndTime",
+        "createdAt",
+        "updatedAt"
+      ])
+    );
+};
+
+const migrateAdditionalPrivilegeData = async (knex: Knex) => {
+  await knex
+    .insert(
+      knex(TableName.ProjectUserAdditionalPrivilege).select(
+        "id",
+        "slug",
+        "isTemporary",
+        "temporaryMode",
+        "temporaryRange",
+        "temporaryAccessStartTime",
+        "temporaryAccessEndTime",
+        "permissions",
+        "userId",
+        "projectId",
+        "createdAt",
+        "updatedAt"
+      )
+    )
+    .into(
+      knex.raw("?? (??,??,??,??,??,??,??,??,??,??,??,??)", [
+        TableName.AdditionalPrivilege,
+        "id",
+        "name",
+        "isTemporary",
+        "temporaryMode",
+        "temporaryRange",
+        "temporaryAccessStartTime",
+        "temporaryAccessEndTime",
+        "permissions",
+        "actorUserId",
+        "projectId",
+        "createdAt",
+        "updatedAt"
+      ])
+    );
+
+  await knex
+    .insert(
+      knex(TableName.IdentityProjectAdditionalPrivilege)
+        .join(
+          TableName.IdentityProjectMembership,
+          `${TableName.IdentityProjectMembership}.id`,
+          `${TableName.IdentityProjectAdditionalPrivilege}.projectMembershipId`
+        )
+        .select(
+          knex.ref("id").withSchema(TableName.IdentityProjectAdditionalPrivilege),
+          "slug",
+          "isTemporary",
+          "temporaryMode",
+          "temporaryRange",
+          "temporaryAccessStartTime",
+          "temporaryAccessEndTime",
+          "permissions",
+          "identityId",
+          "projectId",
+          knex.ref("createdAt").withSchema(TableName.IdentityProjectAdditionalPrivilege),
+          knex.ref("updatedAt").withSchema(TableName.IdentityProjectAdditionalPrivilege)
+        )
+    )
+    .into(
+      knex.raw("?? (??,??,??,??,??,??,??,??,??,??,??,??)", [
+        TableName.AdditionalPrivilege,
+        "id",
+        "name",
+        "isTemporary",
+        "temporaryMode",
+        "temporaryRange",
+        "temporaryAccessStartTime",
+        "temporaryAccessEndTime",
+        "permissions",
+        "actorIdentityId",
+        "projectId",
+        "createdAt",
+        "updatedAt"
+      ])
+    );
+
+  const hasApColumnInAccessApprovalRequest = await knex.schema.hasColumn(
+    TableName.AccessApprovalRequest,
+    "privilegeId"
+  );
+  if (hasApColumnInAccessApprovalRequest) {
+    await knex.schema.alterTable(TableName.AccessApprovalRequest, (t) => {
+      t.dropForeign("privilegeId");
+      t.foreign("privilegeId").references("id").inTable(TableName.AdditionalPrivilege);
+    });
+  }
+};
+
+export async function up(knex: Knex): Promise<void> {
+  const hasToMigrateNamespaceTable = !(await knex.schema.hasTable(TableName.Namespace));
+  if (hasToMigrateNamespaceTable) {
+    await createNamespaceTable(knex);
+  }
+
+  const hasToMigrateMembershipTable = !(await knex.schema.hasTable(TableName.Membership));
+  if (hasToMigrateMembershipTable) {
+    await createMembershipTable(knex);
+  }
+
+  const hasToMigrateRoleTable = !(await knex.schema.hasTable(TableName.Role));
+  if (hasToMigrateRoleTable) {
+    await createRoleTable(knex);
+  }
+
+  const hasToMigrateMembershipRoleTable = !(await knex.schema.hasTable(TableName.MembershipRole));
+  if (hasToMigrateMembershipRoleTable) {
+    await createMembershipRoleTable(knex);
+  }
+
+  const hasToMigrateAdditionalPrivilegeTable = !(await knex.schema.hasTable(TableName.AdditionalPrivilege));
+  if (hasToMigrateAdditionalPrivilegeTable) {
+    await createAdditionalPrivilegeTable(knex);
+  }
+
+  // no mean this has been created before
+  if (hasToMigrateMembershipTable) {
+    await migrateMembershipData(knex);
+  }
+
+  if (hasToMigrateRoleTable) {
+    await migrateRoleData(knex);
+  }
+
+  if (hasToMigrateMembershipRoleTable) {
+    await migrateMembershipRoleData(knex);
+  }
+
+  if (hasToMigrateAdditionalPrivilegeTable) {
+    await migrateAdditionalPrivilegeData(knex);
   }
 }
 
 export async function down(knex: Knex): Promise<void> {
+  // we can bring fk to these tables because the data may not exist anymore
+  // we can do insert back with merge conflict merge in
+  const hasApColumnInAccessApprovalRequest = await knex.schema.hasColumn(
+    TableName.AccessApprovalRequest,
+    "privilegeId"
+  );
+  if (hasApColumnInAccessApprovalRequest) {
+    await knex.schema.alterTable(TableName.AccessApprovalRequest, (t) => {
+      t.dropForeign("privilegeId");
+      t.foreign("privilegeId").references("id").inTable(TableName.ProjectUserAdditionalPrivilege);
+    });
+  }
+
+  const hasExternalGroupRoleMappingRoleColumn = await knex.schema.hasColumn(
+    TableName.ExternalGroupOrgRoleMapping,
+    "roleId"
+  );
+  if (hasExternalGroupRoleMappingRoleColumn) {
+    await knex.schema.alterTable(TableName.ExternalGroupOrgRoleMapping, (t) => {
+      t.dropForeign("roleId");
+      t.foreign("roleId").references("id").inTable(TableName.OrgRoles);
+    });
+  }
+
   await dropOnUpdateTrigger(knex, TableName.AdditionalPrivilege);
   await knex.schema.dropTableIfExists(TableName.AdditionalPrivilege);