@cosmicdrift/kumiko-bundled-features 0.125.2 → 0.127.0

package/src/tenant/feature.ts

@@ -23,6 +23,7 @@ import { resolveUserIdsQuery } from "./handlers/resolve-user-ids.query";
 import { disableWrite, enableWrite } from "./handlers/toggle-enabled.write";
 import { updateWrite } from "./handlers/update.write";
 import { updateMemberRolesWrite } from "./handlers/update-member-roles.write";
+import { TENANT_I18N } from "./i18n";
 import { tenantInvitationEntity } from "./invitation-table";
 import { tenantMembershipEntity } from "./membership-table";
 import { tenantEntity } from "./schema/tenant";
@@ -145,12 +146,14 @@ export function createTenantFeature(): FeatureDefinition {
     });
     r.nav({
       id: "members",
-      label: "tenant:nav.members",
+      label: "tenant.nav.members",
       icon: "users",
       screen: "tenant:screen:members",
       order: 20,
     });
 
+    r.translations({ keys: TENANT_I18N });
+
     return { handlers, queries };
   });
 }

package/src/tenant/handlers/members.query.ts

@@ -2,8 +2,11 @@ import { selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
 import { access, defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
 import { parseRoles } from "@cosmicdrift/kumiko-framework/utils";
 import { z } from "zod";
+import { userTable } from "../../user";
 import { tenantMembershipsTable } from "../membership-table";
 
+type UserRow = { readonly id: unknown; readonly email?: unknown; readonly displayName?: unknown };
+
 export const membersQuery = defineQueryHandler({
   name: "members",
   schema: z.object({}),
@@ -13,9 +16,21 @@ export const membersQuery = defineQueryHandler({
       tenantId: query.user.tenantId,
     });
 
-    return rows.map((row) => ({
-      ...row,
-      roles: parseRoles(row["roles"]),
-    }));
+    const userIds = [...new Set(rows.map((row) => row["userId"]))];
+    const users =
+      userIds.length > 0 ? await selectMany<UserRow>(ctx.db, userTable, { id: userIds }) : [];
+    const userById = new Map(users.map((u) => [String(u.id), u]));
+
+    return rows.map((row) => {
+      const user = userById.get(String(row["userId"]));
+      const email = typeof user?.email === "string" ? user.email : null;
+      const displayName = typeof user?.displayName === "string" ? user.displayName : null;
+      return {
+        ...row,
+        email,
+        displayName,
+        roles: parseRoles(row["roles"]),
+      };
+    });
   },
 });

package/src/tenant/i18n.ts

@@ -0,0 +1,28 @@
+type LocalizedString = { readonly de: string; readonly en: string };
+
+export const TENANT_I18N: Readonly<Record<string, LocalizedString>> = {
+  "screen:tenant-list.title": { de: "Mandanten", en: "Tenants" },
+  "screen:tenant-edit.title": { de: "Mandant bearbeiten", en: "Edit tenant" },
+  "screen:members.title": { de: "Team", en: "Team" },
+  "tenant.nav.members": { de: "Team", en: "Team" },
+  "tenant:entity:tenant:field:key": { de: "Schlüssel", en: "Key" },
+  "tenant:entity:tenant:field:name": { de: "Name", en: "Name" },
+  "tenant:entity:tenant:field:isEnabled": { de: "Aktiv", en: "Enabled" },
+  "tenant:entity:tenant:field:status": { de: "Status", en: "Status" },
+  "tenant:entity:tenant:field:status:option:active": { de: "Aktiv", en: "Active" },
+  "tenant:entity:tenant:field:status:option:destroyRequested": {
+    de: "Löschung angefordert",
+    en: "Destroy requested",
+  },
+  "tenant:entity:tenant:field:status:option:destroying": {
+    de: "Wird gelöscht",
+    en: "Destroying",
+  },
+  "tenant:entity:tenant:field:status:option:destroyFailed": {
+    de: "Löschung fehlgeschlagen",
+    en: "Destroy failed",
+  },
+  "tenant:entity:tenant:field:status:option:destroyed": { de: "Gelöscht", en: "Destroyed" },
+  "tenant:entity:tenant:field:isEnabled:option:true": { de: "Ja", en: "Yes" },
+  "tenant:entity:tenant:field:isEnabled:option:false": { de: "Nein", en: "No" },
+};

package/src/tenant/index.ts

@@ -8,5 +8,10 @@ export {
   tenantInvitationEntity,
   tenantInvitationsTable,
 } from "./invitation-table";
-export { tenantMembershipsTable } from "./membership-table";
-export { tenantEntity, tenantTable } from "./schema/tenant";
+export { tenantMembershipEntity, tenantMembershipsTable } from "./membership-table";
+export {
+  TENANT_LIFECYCLE_STATUSES,
+  type TenantLifecycleStatus,
+  tenantEntity,
+  tenantTable,
+} from "./schema/tenant";

package/src/tenant/schema/tenant.ts

@@ -2,9 +2,21 @@ import { buildEntityTable } from "@cosmicdrift/kumiko-framework/db";
 import {
   createBooleanField,
   createEntity,
+  createSelectField,
   createTextField,
+  createTimestampField,
 } from "@cosmicdrift/kumiko-framework/engine";
 
+export const TENANT_LIFECYCLE_STATUSES = [
+  "active",
+  "destroyRequested",
+  "destroying",
+  "destroyFailed",
+  "destroyed",
+] as const;
+
+export type TenantLifecycleStatus = (typeof TENANT_LIFECYCLE_STATUSES)[number];
+
 export const tenantEntity = createEntity({
   table: "read_tenants",
   // tenant.id IS the tenantId-value that every other table references as FK.
@@ -12,8 +24,21 @@ export const tenantEntity = createEntity({
   // UUID sein, sonst findet der tenants-Lookup nie. Default gen_random_uuid().
   fields: {
     key: createTextField({ required: true, maxLength: 50 }),
-    name: createTextField({ required: true, maxLength: 200, searchable: true }),
-    isEnabled: createBooleanField({ default: true }),
+    name: createTextField({ required: true, maxLength: 200, searchable: true, sortable: true }),
+    isEnabled: createBooleanField({ default: true, filterable: true }),
+    // Tenant-destroy lifecycle (tenant-lifecycle feature). Defaults keep
+    // existing tenants valid when the feature is not mounted.
+    status: createSelectField({
+      options: TENANT_LIFECYCLE_STATUSES,
+      default: "active",
+      required: true,
+      filterable: true,
+    }),
+    destroyRequestedAt: createTimestampField({}),
+    destroyRequestedBy: createTextField({ maxLength: 36 }),
+    gracePeriodEnd: createTimestampField({}),
+    destroyStartedAt: createTimestampField({}),
+    destroyedAt: createTimestampField({}),
   },
   // tenant.key wird in Admin-URLs verwendet (`admin.<host>/<key>/...`) und
   // muss eindeutig sein. Ohne unique-constraint hätte ein konkurrenter

package/src/tenant/screens.ts

@@ -16,7 +16,7 @@ export const tenantListScreen: EntityListScreenDefinition = {
   id: "tenant-list",
   type: "entityList",
   entity: "tenant",
-  columns: ["key", "name", "isEnabled"],
+  columns: ["key", "name", "status", "isEnabled"],
   rowActions: [
     {
       kind: "navigate",
@@ -26,7 +26,8 @@ export const tenantListScreen: EntityListScreenDefinition = {
       entityId: "id",
     },
   ],
-  searchable: false,
+  defaultSort: { field: "name", dir: "asc" },
+  searchable: true,
   access: { roles: ["SystemAdmin"] },
 };
 

package/src/tenant/web/members-screen.tsx

@@ -12,6 +12,8 @@ type MemberRow = {
   readonly id: string;
   readonly userId: string;
   readonly tenantId: string;
+  readonly email: string | null;
+  readonly displayName: string | null;
   readonly roles: readonly string[];
 };
 
@@ -131,8 +133,8 @@ export function MembersScreen({
           testId="members-active-table"
           columns={[
             {
-              field: "userId",
-              label: t("tenant.members.col.userId"),
+              field: "email",
+              label: t("tenant.members.col.email"),
               type: "string",
               sortable: false,
             },
@@ -145,7 +147,10 @@ export function MembersScreen({
           ]}
           rows={state.members.map((m) => ({
             id: m.id,
-            values: { userId: m.userId, roles: m.roles.join(", ") },
+            values: {
+              email: m.email ?? `${m.userId.slice(0, 8)}…`,
+              roles: m.roles.join(", "),
+            },
           }))}
         />
       </Card>

package/src/tenant-lifecycle/__tests__/stages.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, test } from "bun:test";
+import { DESTRUCTION_STAGES, isDestructionPipelineComplete, pickNextStage } from "../stages";
+
+describe("tenant-lifecycle stages", () => {
+  test("pickNextStage halts when any stage was abandoned", () => {
+    const completed = new Set(["external-resources", "search-indices"]);
+    const abandoned = new Set(["app-data"]);
+    expect(pickNextStage(completed, abandoned)).toBeNull();
+  });
+
+  test("pickNextStage returns first incomplete stage when healthy", () => {
+    const completed = new Set(["external-resources"]);
+    expect(pickNextStage(completed, new Set())?.name).toBe("search-indices");
+  });
+
+  test("isDestructionPipelineComplete requires every stage", () => {
+    const partial = new Set(DESTRUCTION_STAGES.slice(0, 3).map((s) => s.name));
+    expect(isDestructionPipelineComplete(partial)).toBe(false);
+    const all = new Set(DESTRUCTION_STAGES.map((s) => s.name));
+    expect(isDestructionPipelineComplete(all)).toBe(true);
+  });
+});