@cosmicdrift/kumiko-testing 0.295.0

package/src/seed-tenant.ts

@@ -0,0 +1,171 @@
+import { randomUUID } from "node:crypto";
+import { hashPassword } from "@cosmicdrift/kumiko-bundled-features/auth-email-password";
+import { TenantHandlers } from "@cosmicdrift/kumiko-bundled-features/tenant";
+import { UserHandlers } from "@cosmicdrift/kumiko-bundled-features/user";
+import { ROLES } from "@cosmicdrift/kumiko-framework/auth";
+import {
+  createSystemUser,
+  type SessionUser,
+  type TenantId,
+  type WriteResult,
+} from "@cosmicdrift/kumiko-framework/engine";
+import type { TestStack } from "@cosmicdrift/kumiko-framework/stack";
+import { isPlainObject } from "@cosmicdrift/kumiko-framework/utils";
+import {
+  type BoundApi,
+  type SeededCredentials,
+  type SeededTenant,
+  type SeedTenantOptions,
+  withSession,
+} from "./seed-types";
+
+export type {
+  BoundApi,
+  SeededCredentials,
+  SeededTenant,
+  SeededUser,
+  SeedPart,
+  SeedTenantOptions,
+} from "./seed-types";
+
+export type SavedRow = { readonly id: string; readonly data: { readonly version: number } };
+
+export type SeedWriter = (
+  handlerQn: string,
+  payload: unknown,
+  tenantId: TenantId,
+) => Promise<SavedRow>;
+
+export type PersistedTenant = {
+  readonly id: TenantId;
+  readonly key: string;
+  readonly name: string;
+  readonly admin: SeededCredentials;
+  readonly members: readonly SeededCredentials[];
+};
+
+function bindApi(stack: TestStack, user: SessionUser): BoundApi {
+  const { http } = stack;
+  return {
+    writeOk: (type, payload, requestId) => http.writeOk(type, payload, user, requestId),
+    writeErr: (type, payload) => http.writeErr(type, payload, user),
+    queryOk: (type, payload) => http.queryOk(type, payload, user),
+    queryErr: (type, payload) => http.queryErr(type, payload, user),
+  };
+}
+
+function lightCredentials(): SeededCredentials {
+  const id = randomUUID();
+  return { id, email: `user-${id}@example.test`, password: `pw-${randomUUID()}` };
+}
+
+function newTenantIdentity(name: string | undefined): {
+  id: TenantId;
+  key: string;
+  name: string;
+} {
+  const id: TenantId = randomUUID();
+  return { id, key: `t-${id}`, name: name ?? `Test Tenant ${id.slice(0, 8)}` };
+}
+
+function isSavedRow(value: unknown): value is SavedRow {
+  if (!isPlainObject(value) || typeof value["id"] !== "string") return false;
+  const data = value["data"];
+  return isPlainObject(data) && typeof data["version"] === "number";
+}
+
+export function unwrapSavedRow(handlerQn: string, result: WriteResult): SavedRow {
+  if (!result.isSuccess) {
+    throw new Error(`seedTenant: ${handlerQn} failed: ${JSON.stringify(result.error)}`);
+  }
+  if (!isSavedRow(result.data)) {
+    throw new Error(`seedTenant: ${handlerQn} returned no saved row`);
+  }
+  return result.data;
+}
+
+export function stackSeedWriter(stack: TestStack): SeedWriter {
+  return async (handlerQn, payload, tenantId) =>
+    unwrapSavedRow(
+      handlerQn,
+      await stack.dispatcher.write(
+        handlerQn,
+        payload,
+        createSystemUser(tenantId, [ROLES.SystemAdmin]),
+      ),
+    );
+}
+
+export async function persistUserRows(
+  write: SeedWriter,
+  tenantId: TenantId,
+  roles: readonly string[],
+): Promise<SeededCredentials> {
+  const light = lightCredentials();
+  const created = await write(
+    UserHandlers.create,
+    {
+      email: light.email,
+      passwordHash: await hashPassword(light.password),
+      displayName: `Seed ${light.id.slice(0, 8)}`,
+    },
+    tenantId,
+  );
+  await write(
+    UserHandlers.update,
+    { id: created.id, version: created.data.version, changes: { emailVerified: true } },
+    tenantId,
+  );
+  await write(TenantHandlers.addMember, { userId: created.id, tenantId, roles }, tenantId);
+  return { id: created.id, email: light.email, password: light.password };
+}
+
+export async function persistTenantRows(
+  write: SeedWriter,
+  opts: { readonly name?: string; readonly users?: number } = {},
+): Promise<PersistedTenant> {
+  const { id, key, name } = newTenantIdentity(opts.name);
+  await write(TenantHandlers.create, { id, key, name }, id);
+  const admin = await persistUserRows(write, id, [ROLES.TenantAdmin]);
+  const members: SeededCredentials[] = [];
+  for (let i = 0; i < (opts.users ?? 0); i++) {
+    members.push(await persistUserRows(write, id, [ROLES.Member]));
+  }
+  return { id, key, name, admin, members };
+}
+
+function lightTenantRows(opts: SeedTenantOptions): PersistedTenant {
+  const identity = newTenantIdentity(opts.name);
+  const members = Array.from({ length: opts.users ?? 0 }, lightCredentials);
+  return { ...identity, admin: lightCredentials(), members };
+}
+
+export async function seedTenant(
+  stack: TestStack,
+  opts: SeedTenantOptions = {},
+): Promise<SeededTenant> {
+  const write = stackSeedWriter(stack);
+  const persist = opts.persist === true;
+  const rows = persist ? await persistTenantRows(write, opts) : lightTenantRows(opts);
+  const { id } = rows;
+
+  const admin = withSession(rows.admin, id, [ROLES.TenantAdmin]);
+  const tenant: SeededTenant = {
+    id,
+    key: rows.key,
+    name: rows.name,
+    admin,
+    members: rows.members.map((member) => withSession(member, id, [ROLES.Member])),
+    addUser: async (roles = [ROLES.Member]) =>
+      withSession(
+        persist ? await persistUserRows(write, id, roles) : lightCredentials(),
+        id,
+        roles,
+      ),
+    api: bindApi(stack, admin.session),
+    apiAs: (user) => bindApi(stack, user.session),
+  };
+
+  for (const part of opts.with ?? []) await part({ tenant });
+  return tenant;
+}

package/src/seed-types.ts

@@ -0,0 +1,49 @@
+import type { SessionUser, TenantId } from "@cosmicdrift/kumiko-framework/engine";
+import type { WriteErrorInfo } from "@cosmicdrift/kumiko-framework/errors";
+
+export type BoundApi = {
+  writeOk: <T = Record<string, unknown>>(
+    type: string,
+    payload: unknown,
+    requestId?: string,
+  ) => Promise<T>;
+  writeErr: (type: string, payload: unknown) => Promise<WriteErrorInfo>;
+  queryOk: <T = unknown>(type: string, payload: unknown) => Promise<T>;
+  queryErr: (type: string, payload: unknown) => Promise<WriteErrorInfo>;
+};
+
+export type SeededCredentials = {
+  readonly id: string;
+  readonly email: string;
+  readonly password: string;
+};
+
+export type SeededUser = SeededCredentials & { readonly session: SessionUser };
+
+export type SeedPart = (ctx: { readonly tenant: SeededTenant }) => Promise<void>;
+
+export type SeedTenantOptions = {
+  readonly name?: string;
+  readonly users?: number;
+  readonly with?: readonly SeedPart[];
+  readonly persist?: boolean;
+};
+
+export type SeededTenant = {
+  readonly id: TenantId;
+  readonly key: string;
+  readonly name: string;
+  readonly admin: SeededUser;
+  readonly members: readonly SeededUser[];
+  readonly addUser: (roles?: readonly string[]) => Promise<SeededUser>;
+  readonly api: BoundApi;
+  readonly apiAs: (user: SeededUser) => BoundApi;
+};
+
+export function withSession(
+  credentials: SeededCredentials,
+  tenantId: TenantId,
+  roles: readonly string[],
+): SeededUser {
+  return { ...credentials, session: { id: credentials.id, tenantId, roles } };
+}

package/src/setup-app-test-stack.ts

@@ -0,0 +1,26 @@
+import {
+  type SetupTestStackFromFeaturesOptions,
+  setupTestStackFromFeatures,
+} from "@cosmicdrift/kumiko-dev-server/setup-test-stack-from-features";
+import type { FeatureDefinition } from "@cosmicdrift/kumiko-framework/engine";
+import { pushEntityProjectionTables, type TestStack } from "@cosmicdrift/kumiko-framework/stack";
+
+export type SetupAppTestStackOptions = SetupTestStackFromFeaturesOptions & {
+  readonly registryTables?: boolean;
+};
+
+export async function setupAppTestStack(
+  features: readonly FeatureDefinition[],
+  options: SetupAppTestStackOptions = {},
+): Promise<TestStack> {
+  const { registryTables = true, includeBundled = true, ...stackOptions } = options;
+  const stack = await setupTestStackFromFeatures(features, { ...stackOptions, includeBundled });
+  if (!registryTables) return stack;
+  try {
+    await pushEntityProjectionTables(stack, stack.registry);
+  } catch (error) {
+    await stack.cleanup();
+    throw error;
+  }
+  return stack;
+}