@teamblind/axeda-testing 0.0.0-stage → 0.1.0-alpha.1

package/dist/memory-tenants.js

@@ -0,0 +1,248 @@
+import { AxedaError, businessKey, companyKey, scopeKey, withoutSecret, } from '@teamblind/axeda-core';
+export const encodeCursor = (value) => Buffer.from(value, 'utf8').toString('base64url');
+export const decodeCursor = (cursor) => Buffer.from(cursor, 'base64url').toString('utf8');
+/** Pagina una lista ya ordenada por `key` con un cursor opaco. */
+export function paginate(sorted, key, page) {
+    const after = page.cursor === undefined ? null : decodeCursor(page.cursor);
+    const remaining = after === null ? sorted : sorted.filter((item) => key(item) > after);
+    const items = remaining.slice(0, page.limit);
+    const last = items.at(-1);
+    return {
+        items,
+        nextCursor: remaining.length > items.length && last ? encodeCursor(key(last)) : null,
+    };
+}
+const matches = (entity, filter) => {
+    if (filter.ids !== undefined && !filter.ids.includes(entity.id))
+        return false;
+    const deleted = filter.deleted ?? 'exclude';
+    if (deleted === 'exclude')
+        return entity.deletedAt === null;
+    if (deleted === 'only')
+        return entity.deletedAt !== null;
+    return true;
+};
+const conflict = (kind, id, found, expected) => new AxedaError('AXEDA_VERSION_CONFLICT', `${kind} "${id}" is at version ${found}, not ${expected}.`);
+/** Quita asignaciones e invitaciones de los alcances indicados (claves de `scopeKey`). */
+function dropScopes(state, keys) {
+    for (const [id, assignment] of state.assignments) {
+        if (keys.has(scopeKey(assignment.scope)))
+            state.assignments.delete(id);
+    }
+    for (const [id, invitation] of state.invitations) {
+        if (keys.has(scopeKey(invitation.scope)))
+            state.invitations.delete(id);
+    }
+}
+export function createCompanyStore(context) {
+    const { state, run, now, nextId } = context;
+    const need = (id, expectedVersion) => {
+        const current = state.companies.get(id);
+        if (!current)
+            throw new AxedaError('AXEDA_COMPANY_NOT_FOUND', `Company "${id}" does not exist.`);
+        if (current.version !== expectedVersion)
+            throw conflict('Company', id, current.version, expectedVersion);
+        return current;
+    };
+    const save = (company, patch) => {
+        const next = { ...company, ...patch, version: company.version + 1, updatedAt: now() };
+        state.companies.set(company.id, next);
+        return next;
+    };
+    return {
+        get: (id) => run(async () => state.companies.get(id) ?? null),
+        getMany: (ids) => run(async () => ids.flatMap((id) => state.companies.get(id) ?? [])),
+        getBySlug: (slug) => run(async () => [...state.companies.values()].find((company) => company.slug === slug) ?? null),
+        list: (filter, page) => run(async () => {
+            const sorted = [...state.companies.values()]
+                .filter((company) => matches(company, filter))
+                .sort((a, b) => a.slug.localeCompare(b.slug));
+            return paginate(sorted, (company) => company.slug, page);
+        }),
+        create: (input) => run(async () => {
+            if ([...state.companies.values()].some((company) => company.slug === input.slug)) {
+                throw new AxedaError('AXEDA_SLUG_TAKEN', `A company with slug "${input.slug}" already exists.`);
+            }
+            const at = now();
+            const company = {
+                id: nextId(),
+                slug: input.slug,
+                name: input.name,
+                legalName: input.legalName ?? null,
+                logoUrl: input.logoUrl ?? null,
+                faviconUrl: input.faviconUrl ?? null,
+                status: 'active',
+                metadata: input.metadata ?? {},
+                version: 1,
+                deletedAt: null,
+                createdAt: at,
+                updatedAt: at,
+            };
+            state.companies.set(company.id, company);
+            return company;
+        }),
+        update: (id, expectedVersion, changes) => run(async () => {
+            const current = need(id, expectedVersion);
+            return save(current, {
+                name: changes.name ?? current.name,
+                legalName: changes.legalName === undefined ? current.legalName : changes.legalName,
+                logoUrl: changes.logoUrl === undefined ? current.logoUrl : changes.logoUrl,
+                faviconUrl: changes.faviconUrl === undefined ? current.faviconUrl : changes.faviconUrl,
+                metadata: changes.metadata ?? current.metadata,
+            });
+        }),
+        setStatus: (id, expectedVersion, status) => run(async () => save(need(id, expectedVersion), { status })),
+        setDeleted: (id, expectedVersion, at) => run(async () => save(need(id, expectedVersion), { deletedAt: at })),
+        listDeletedBefore: (before, limit) => run(async () => [...state.companies.values()]
+            .filter((company) => company.deletedAt !== null && company.deletedAt < before)
+            .sort((a, b) => a.slug.localeCompare(b.slug))
+            .slice(0, limit)),
+        purge: (ids) => run(async () => {
+            const doomed = new Set(ids.filter((id) => state.companies.has(id)));
+            const keys = new Set([...doomed].map(companyKey));
+            for (const [businessId, business] of state.businesses) {
+                if (doomed.has(business.companyId)) {
+                    keys.add(businessKey(businessId));
+                    state.businesses.delete(businessId);
+                }
+            }
+            for (const id of doomed)
+                state.companies.delete(id);
+            dropScopes(state, keys);
+            return doomed.size;
+        }),
+    };
+}
+export function createBusinessStore(context) {
+    const { state, run, now, nextId } = context;
+    const need = (id, expectedVersion) => {
+        const current = state.businesses.get(id);
+        if (!current)
+            throw new AxedaError('AXEDA_BUSINESS_NOT_FOUND', `Business "${id}" does not exist.`);
+        if (current.version !== expectedVersion)
+            throw conflict('Business', id, current.version, expectedVersion);
+        return current;
+    };
+    const save = (business, patch) => {
+        const next = {
+            ...business,
+            ...patch,
+            version: business.version + 1,
+            updatedAt: now(),
+        };
+        state.businesses.set(business.id, next);
+        return next;
+    };
+    return {
+        get: (id) => run(async () => state.businesses.get(id) ?? null),
+        getMany: (ids) => run(async () => ids.flatMap((id) => state.businesses.get(id) ?? [])),
+        getBySlug: (companyId, slug) => run(async () => [...state.businesses.values()].find((business) => business.companyId === companyId && business.slug === slug) ?? null),
+        listForCompany: (companyId, filter, page) => run(async () => {
+            const sorted = [...state.businesses.values()]
+                .filter((business) => business.companyId === companyId && matches(business, filter))
+                .sort((a, b) => a.slug.localeCompare(b.slug));
+            return paginate(sorted, (business) => business.slug, page);
+        }),
+        create: (input) => run(async () => {
+            if (!state.companies.has(input.companyId)) {
+                throw new AxedaError('AXEDA_COMPANY_NOT_FOUND', `Company "${input.companyId}" does not exist.`);
+            }
+            const taken = [...state.businesses.values()].some((business) => business.companyId === input.companyId && business.slug === input.slug);
+            if (taken) {
+                throw new AxedaError('AXEDA_SLUG_TAKEN', `A business with slug "${input.slug}" already exists in that company.`);
+            }
+            const at = now();
+            const business = {
+                id: nextId(),
+                companyId: input.companyId,
+                slug: input.slug,
+                name: input.name,
+                logoUrl: input.logoUrl ?? null,
+                faviconUrl: input.faviconUrl ?? null,
+                status: 'active',
+                metadata: input.metadata ?? {},
+                version: 1,
+                deletedAt: null,
+                createdAt: at,
+                updatedAt: at,
+            };
+            state.businesses.set(business.id, business);
+            return business;
+        }),
+        update: (id, expectedVersion, changes) => run(async () => {
+            const current = need(id, expectedVersion);
+            return save(current, {
+                name: changes.name ?? current.name,
+                logoUrl: changes.logoUrl === undefined ? current.logoUrl : changes.logoUrl,
+                faviconUrl: changes.faviconUrl === undefined ? current.faviconUrl : changes.faviconUrl,
+                metadata: changes.metadata ?? current.metadata,
+            });
+        }),
+        setStatus: (id, expectedVersion, status) => run(async () => save(need(id, expectedVersion), { status })),
+        setDeleted: (id, expectedVersion, at) => run(async () => save(need(id, expectedVersion), { deletedAt: at })),
+        listDeletedBefore: (before, limit) => run(async () => [...state.businesses.values()]
+            .filter((business) => business.deletedAt !== null && business.deletedAt < before)
+            .sort((a, b) => a.id.localeCompare(b.id))
+            .slice(0, limit)),
+        purge: (ids) => run(async () => {
+            const doomed = ids.filter((id) => state.businesses.has(id));
+            for (const id of doomed)
+                state.businesses.delete(id);
+            dropScopes(state, new Set(doomed.map(businessKey)));
+            return doomed.length;
+        }),
+    };
+}
+const isPending = (invitation) => invitation.acceptedAt === null && invitation.revokedAt === null;
+export function createInvitationStore(context) {
+    const { state, run, nextId, now } = context;
+    return {
+        get: (id) => run(async () => state.invitations.get(id) ?? null),
+        findPending: (email, scope) => run(async () => [...state.invitations.values()].find((invitation) => isPending(invitation) &&
+            invitation.email === email &&
+            scopeKey(invitation.scope) === scopeKey(scope)) ?? null),
+        create: (input) => run(async () => {
+            const exists = [...state.invitations.values()].some((invitation) => isPending(invitation) &&
+                invitation.email === input.email &&
+                scopeKey(invitation.scope) === scopeKey(input.scope));
+            if (exists) {
+                throw new AxedaError('AXEDA_INVITATION_EXISTS', 'There is already a pending invitation for that email and scope.');
+            }
+            const invitation = {
+                id: nextId(),
+                email: input.email,
+                scope: input.scope,
+                roleIds: [...input.roleIds],
+                invitedBy: input.invitedBy,
+                expiresAt: input.expiresAt,
+                secretHash: input.secretHash,
+                createdAt: now(),
+                acceptedAt: null,
+                revokedAt: null,
+            };
+            state.invitations.set(invitation.id, invitation);
+            return invitation;
+        }),
+        close: (id, outcome, at) => run(async () => {
+            const current = state.invitations.get(id);
+            if (!current || !isPending(current))
+                return false;
+            state.invitations.set(id, {
+                ...current,
+                ...(outcome === 'accepted' ? { acceptedAt: at } : { revokedAt: at }),
+            });
+            return true;
+        }),
+        list: (scope, options, page) => run(async () => {
+            const sorted = [...state.invitations.values()]
+                .filter((invitation) => scopeKey(invitation.scope) === scopeKey(scope))
+                .filter((invitation) => !options.pendingOnly || (isPending(invitation) && invitation.expiresAt > options.now))
+                .sort((a, b) => a.id.localeCompare(b.id));
+            const { items, nextCursor } = paginate(sorted, (invitation) => invitation.id, page);
+            return {
+                items: items.map(withoutSecret),
+                nextCursor,
+            };
+        }),
+    };
+}

package/dist/memory-users.d.ts

@@ -0,0 +1,17 @@
+import { type ManagedUser, type UserAdmin, type UserDirectory } from '@teamblind/axeda-core';
+export type MemoryUserInput = Partial<Omit<ManagedUser, 'id'>> & {
+    id: string;
+};
+export interface MemoryUserDirectory extends UserDirectory, UserAdmin {
+    /** Añade o reemplaza un usuario. */
+    add(user: MemoryUserInput): ManagedUser;
+    remove(userId: string): void;
+    /** Simula `count` sesiones abiertas del usuario. */
+    addSessions(userId: string, count: number): void;
+    sessionsOf(userId: string): number;
+}
+export interface MemoryUsersOptions {
+    readonly now?: () => Date;
+}
+/** Directorio y administración de usuarios en memoria para las pruebas del núcleo. */
+export declare function createMemoryUserDirectory(initial?: readonly MemoryUserInput[], options?: MemoryUsersOptions): MemoryUserDirectory;

package/dist/memory-users.js

@@ -0,0 +1,111 @@
+import { AxedaError, isBanned, } from '@teamblind/axeda-core';
+import { decodeCursor, encodeCursor } from './memory-tenants.js';
+/** Directorio y administración de usuarios en memoria para las pruebas del núcleo. */
+export function createMemoryUserDirectory(initial = [], options = {}) {
+    const now = options.now ?? (() => new Date());
+    const users = new Map();
+    const add = (user) => {
+        const full = {
+            email: `${user.id}@test.dev`,
+            name: user.id,
+            emailVerified: true,
+            twoFactorEnabled: false,
+            banned: false,
+            banReason: null,
+            banExpires: null,
+            createdAt: now(),
+            sessions: 0,
+            ...user,
+        };
+        users.set(full.id, full);
+        return full;
+    };
+    for (const user of initial)
+        add(user);
+    /** El estado de bloqueo se calcula siempre con la hora actual. */
+    const view = (user) => ({
+        id: user.id,
+        email: user.email,
+        name: user.name,
+        emailVerified: user.emailVerified,
+        twoFactorEnabled: user.twoFactorEnabled,
+        banned: isBanned(user, now()),
+        banReason: user.banReason,
+        banExpires: user.banExpires,
+        createdAt: user.createdAt,
+    });
+    const need = (userId) => {
+        const user = users.get(userId);
+        if (user === undefined) {
+            throw new AxedaError('AXEDA_USER_NOT_FOUND', `User "${userId}" does not exist.`);
+        }
+        return user;
+    };
+    const toDirectory = (user) => ({
+        id: user.id,
+        email: user.email,
+        emailVerified: user.emailVerified,
+        twoFactorEnabled: user.twoFactorEnabled,
+        banned: isBanned(user, now()),
+    });
+    return {
+        add,
+        remove: (userId) => void users.delete(userId),
+        addSessions: (userId, count) => void (need(userId).sessions += count),
+        sessionsOf: (userId) => users.get(userId)?.sessions ?? 0,
+        find: async (userId) => {
+            const user = users.get(userId);
+            return user === undefined ? null : toDirectory(user);
+        },
+        findByEmail: async (email) => {
+            const user = [...users.values()].find((u) => u.email.toLowerCase() === email.toLowerCase());
+            return user === undefined ? null : toDirectory(user);
+        },
+        get: async (userId) => {
+            const user = users.get(userId);
+            return user === undefined ? null : view(user);
+        },
+        list: async (filter, page) => {
+            const prefix = filter.emailPrefix?.toLowerCase();
+            const after = page.cursor === undefined ? null : decodeCursor(page.cursor);
+            const sorted = [...users.values()]
+                .filter((u) => prefix === undefined || u.email.toLowerCase().startsWith(prefix))
+                .filter((u) => filter.banned === undefined || isBanned(u, now()) === filter.banned)
+                .sort((a, b) => a.id.localeCompare(b.id))
+                .filter((u) => after === null || u.id > after);
+            const items = sorted.slice(0, page.limit);
+            const last = items.at(-1);
+            return {
+                items: items.map(view),
+                nextCursor: sorted.length > items.length && last ? encodeCursor(last.id) : null,
+            };
+        },
+        create: async (input) => {
+            const email = input.email.toLowerCase();
+            if ([...users.values()].some((u) => u.email.toLowerCase() === email)) {
+                throw new AxedaError('AXEDA_EMAIL_TAKEN', 'That email already has an account.');
+            }
+            return view(add({
+                id: globalThis.crypto.randomUUID(),
+                email,
+                name: input.name,
+                emailVerified: false,
+            }));
+        },
+        setBan: async (userId, ban) => {
+            const user = need(userId);
+            Object.assign(user, {
+                banned: ban !== null,
+                banReason: ban?.reason ?? null,
+                banExpires: ban?.expiresAt ?? null,
+            });
+            return view(user);
+        },
+        revokeSessions: async (userId) => {
+            const user = need(userId);
+            const closed = user.sessions;
+            user.sessions = 0;
+            return closed;
+        },
+    };
+}

package/dist/persistence-contract.d.ts

@@ -0,0 +1,13 @@
+import { type AxedaPersistence, type NewRole } from '@teamblind/axeda-core';
+/**
+ * Usuarios que la suite usa. Las persistencias respaldadas por una base con claves foráneas
+ * (Better Auth) deben tenerlos creados antes de empezar; la de memoria los ignora.
+ */
+export declare const CONTRACT_USERS: readonly string[];
+export type PersistenceFactory = (users: readonly string[]) => AxedaPersistence | Promise<AxedaPersistence>;
+export declare const roleInput: (overrides?: Partial<NewRole>) => NewRole;
+/**
+ * Suite de contrato de los puertos de persistencia de Axeda. Toda implementación (memoria,
+ * Better Auth sobre SQLite o PostgreSQL, …) debe pasarla entera.
+ */
+export declare function runPersistenceContract(name: string, create: PersistenceFactory): void;