@nlabs/reaktor 1.16.0 → 1.18.0

package/lib/organizations/membership.d.ts

@@ -0,0 +1,19 @@
+import { type OrganizationTransaction, type Stored } from './store.js';
+import type { ApiContext } from '../types/auth.types.js';
+import type { MembershipChange, Organization, OrganizationMembership } from './types.js';
+export declare const activeMemberCount: (tx: OrganizationTransaction, organizationId: string) => Promise<number>;
+export declare const writeSeatChange: (tx: OrganizationTransaction, org: Stored<Organization>, quantity: number, effectiveAt: number, previousQuantity: number) => Promise<void>;
+export declare const validateSeatQuote: (tx: OrganizationTransaction, org: Organization, change: MembershipChange, quantity: number) => Promise<void>;
+export declare const changeOrganizationMember: (context: ApiContext, organizationId: string, change: MembershipChange) => Promise<OrganizationMembership>;
+export declare const requestOwnershipTransfer: (context: ApiContext, organizationId: string, recipientUserId: string) => Promise<{
+    transferId: string;
+}>;
+export declare const acceptOwnershipTransfer: (context: ApiContext, transferId: string) => Promise<Organization>;
+export declare const inviteOrganizationMember: (context: ApiContext, organizationId: string, email: string, acceptsAdditionalSeatCharge: boolean) => Promise<{
+    invitationId: string;
+    token: string;
+}>;
+export declare const acceptOrganizationInvitation: (context: ApiContext, invitationId: string, token: string) => Promise<OrganizationMembership>;
+export declare const revokeOrganizationInvitation: (context: ApiContext, invitationId: string) => Promise<void>;
+export declare const assertOrganizationAccountRemovalAllowed: (context: ApiContext, userId: string) => Promise<void>;
+export declare const listOrganizationMembers: (context: ApiContext, organizationId: string) => Promise<OrganizationMembership[]>;

package/lib/organizations/membership.js

@@ -0,0 +1,248 @@
+import { randomBytes } from 'node:crypto';
+import { organizationAccessInTransaction, organizationUserId } from './authorization.js';
+import { newOrganizationId, organizationKey, organizationStoreFor, requireIdentifier } from './store.js';
+export const activeMemberCount = async (tx, organizationId)=>(await tx.find('organizationMemberships', {
+        organizationId,
+        status: 'active'
+    })).length;
+export const writeSeatChange = async (tx, org, quantity, effectiveAt, previousQuantity)=>{
+    const revision = org.revision + 1;
+    await tx.put('organizations', org.organizationId, {
+        ...org,
+        revision,
+        updatedAt: effectiveAt
+    }, org);
+    const jobId = organizationKey(org.organizationId, String(revision));
+    const job = {
+        attempts: 0,
+        desired: {
+            extraSeats: Math.max(0, quantity - 10),
+            previousExtraSeats: Math.max(0, previousQuantity - 10)
+        },
+        effectiveAt,
+        jobId,
+        kind: 'seats',
+        leaseExpires: 0,
+        organizationId: org.organizationId,
+        owner: '',
+        priceVersion: '2026-10-v1',
+        sequence: revision,
+        status: 'pending'
+    };
+    await tx.put('organizationBillingJobs', jobId, job);
+};
+export const validateSeatQuote = async (tx, org, change, quantity)=>{
+    const quote = change.confirmedQuoteId ? await tx.get('organizationBillingQuotes', change.confirmedQuoteId) : null;
+    if (!quote || quote.used || quote.organizationRevision !== org.revision || quote.organizationId !== org.organizationId || quote.expectedRevision !== change.expectedRevision || quote.role !== change.role || quote.expiresAt <= Date.now() || quote.userId !== change.userId || quote.status !== change.status || quote.quantity !== quantity) {
+        throw new Error('seat_quote_required');
+    }
+    await tx.put('organizationBillingQuotes', quote._key, {
+        ...quote,
+        used: true
+    }, quote);
+};
+export const changeOrganizationMember = (context, organizationId, change)=>organizationStoreFor(context).transaction(async (tx)=>{
+        const access = await organizationAccessInTransaction(tx, context, organizationId, 'admin');
+        const org = await tx.get('organizations', organizationId);
+        const member = await tx.get('organizationMemberships', organizationKey(organizationId, requireIdentifier(change.userId)));
+        if (![
+            'admin',
+            'member'
+        ].includes(change.role) || ![
+            'active',
+            'deactivated'
+        ].includes(change.status) || !Number.isSafeInteger(change.expectedRevision)) {
+            throw new Error('invalid_membership');
+        }
+        if (!org || !member || member.revision !== change.expectedRevision) {
+            throw new Error('revision_conflict');
+        }
+        if (access.organization.ownerUserId === member.userId && (change.role !== 'admin' || change.status !== 'active')) {
+            throw new Error('ownership_transfer_required');
+        }
+        const user = await tx.get('users', member.userId);
+        if (change.status === 'active' && (!user?.active || !user.verifiedEmail)) {
+            throw new Error('verified_active_user_required');
+        }
+        const count = await activeMemberCount(tx, organizationId);
+        const nextCount = count + Number(change.status === 'active') - Number(member.status === 'active');
+        const billing = await tx.get('organizationBilling', organizationId);
+        if (nextCount > count && nextCount > 10 && billing?.plan) {
+            if (billing.status !== 'active') {
+                throw new Error('billing_not_ready');
+            }
+            await validateSeatQuote(tx, org, change, Math.max(0, nextCount - 10));
+        }
+        const now = Date.now();
+        const updated = {
+            ...member,
+            revision: member.revision + 1,
+            role: change.role,
+            status: change.status,
+            updatedAt: now
+        };
+        await tx.put('organizationMemberships', member._key, updated, member);
+        await writeSeatChange(tx, org, nextCount, now, count);
+        return updated;
+    });
+export const requestOwnershipTransfer = (context, organizationId, recipientUserId)=>organizationStoreFor(context).transaction(async (tx)=>{
+        const { organization } = await organizationAccessInTransaction(tx, context, organizationId, 'owner');
+        const recipient = await tx.get('organizationMemberships', organizationKey(organizationId, requireIdentifier(recipientUserId)));
+        if (!recipient || recipient.status !== 'active' || recipientUserId === organization.ownerUserId) {
+            throw new Error('active_recipient_required');
+        }
+        const transferId = newOrganizationId();
+        await tx.put('organizationOwnerTransfers', transferId, {
+            expiresAt: Date.now() + 48 * 3600000,
+            organizationId,
+            ownerUserId: organization.ownerUserId,
+            recipientUserId,
+            revision: organization.revision,
+            used: false
+        });
+        return {
+            transferId
+        };
+    });
+export const acceptOwnershipTransfer = (context, transferId)=>organizationStoreFor(context).transaction(async (tx)=>{
+        const transfer = await tx.get('organizationOwnerTransfers', requireIdentifier(transferId));
+        if (!transfer || transfer.used || transfer.expiresAt <= Date.now() || transfer.recipientUserId !== organizationUserId(context)) {
+            throw new Error('invalid_transfer');
+        }
+        const access = await organizationAccessInTransaction(tx, context, transfer.organizationId, 'member');
+        const org = await tx.get('organizations', transfer.organizationId);
+        const member = await tx.get('organizationMemberships', organizationKey(transfer.organizationId, access.userId));
+        if (!org || !member || org.ownerUserId !== transfer.ownerUserId || org.revision !== transfer.revision) {
+            throw new Error('invalid_transfer');
+        }
+        const now = Date.now();
+        const updated = {
+            ...org,
+            ownerUserId: access.userId,
+            revision: org.revision + 1,
+            updatedAt: now
+        };
+        await tx.put('organizations', org._key, updated, org);
+        await tx.put('organizationMemberships', member._key, {
+            ...member,
+            revision: member.revision + 1,
+            role: 'admin',
+            updatedAt: now
+        }, member);
+        await tx.put('organizationOwnerTransfers', transfer._key, {
+            ...transfer,
+            used: true
+        }, transfer);
+        const user = await tx.get('users', access.userId);
+        if (!user) {
+            throw new Error('organization_state_invalid');
+        }
+        await tx.put('users', access.userId, {
+            ...user,
+            organizationAccount: true
+        }, user);
+        return updated;
+    });
+export const inviteOrganizationMember = (context, organizationId, email, acceptsAdditionalSeatCharge)=>organizationStoreFor(context).transaction(async (tx)=>{
+        const access = await organizationAccessInTransaction(tx, context, organizationId, 'admin');
+        const normalized = email.trim().toLowerCase();
+        if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(normalized) || !acceptsAdditionalSeatCharge) {
+            throw new Error('invitation_charge_disclosure_required');
+        }
+        const existing = (await tx.find('organizationInvitations', {
+            email: normalized,
+            organizationId
+        })).find((invitation)=>!invitation.used && !invitation.revoked && invitation.expiresAt > Date.now());
+        if (existing) {
+            throw new Error('invitation_exists');
+        }
+        const invitationId = newOrganizationId();
+        const token = randomBytes(32).toString('base64url');
+        await tx.put('organizationInvitations', invitationId, {
+            email: normalized,
+            expiresAt: Date.now() + 7 * 86400000,
+            invitedBy: access.userId,
+            organizationId,
+            revoked: false,
+            tokenHash: organizationKey(token),
+            used: false
+        });
+        return {
+            invitationId,
+            token
+        };
+    });
+export const acceptOrganizationInvitation = (context, invitationId, token)=>organizationStoreFor(context).transaction(async (tx)=>{
+        const userId = organizationUserId(context);
+        const invitation = await tx.get('organizationInvitations', requireIdentifier(invitationId));
+        const user = await tx.get('users', userId);
+        if (!invitation || invitation.revoked || invitation.used || invitation.expiresAt <= Date.now() || invitation.tokenHash !== organizationKey(token) || !user?.active || !user.verifiedEmail || user.email.toLowerCase() !== invitation.email) {
+            throw new Error('invalid_invitation');
+        }
+        await organizationAccessInTransaction(tx, {
+            session: {
+                userId: invitation.invitedBy
+            }
+        }, invitation.organizationId, 'admin');
+        const org = await tx.get('organizations', invitation.organizationId);
+        if (!org) {
+            throw new Error('organization_access_denied');
+        }
+        const key = organizationKey(invitation.organizationId, userId);
+        const previous = await tx.get('organizationMemberships', key);
+        if (previous?.status === 'active') {
+            throw new Error('already_active');
+        }
+        const now = Date.now();
+        const member = {
+            createdAt: previous?.createdAt || now,
+            organizationId: org.organizationId,
+            revision: (previous?.revision || 0) + 1,
+            role: previous?.role || 'member',
+            status: 'active',
+            updatedAt: now,
+            userId
+        };
+        const previousCount = await activeMemberCount(tx, org.organizationId);
+        const billing = await tx.get('organizationBilling', org.organizationId);
+        if (previousCount >= 10 && billing?.plan && billing.status !== 'active') {
+            throw new Error('billing_not_ready');
+        }
+        await tx.put('organizationMemberships', key, member, previous);
+        await tx.put('users', userId, {
+            ...user,
+            organizationAccount: true
+        }, user);
+        await writeSeatChange(tx, org, previousCount + 1, now, previousCount);
+        await tx.put('organizationInvitations', invitationId, {
+            ...invitation,
+            used: true
+        }, invitation);
+        return member;
+    });
+export const revokeOrganizationInvitation = (context, invitationId)=>organizationStoreFor(context).transaction(async (tx)=>{
+        const invitation = await tx.get('organizationInvitations', requireIdentifier(invitationId));
+        if (!invitation) {
+            throw new Error('invalid_invitation');
+        }
+        await organizationAccessInTransaction(tx, context, invitation.organizationId, 'admin');
+        await tx.put('organizationInvitations', invitationId, {
+            ...invitation,
+            revoked: true
+        }, invitation);
+    });
+export const assertOrganizationAccountRemovalAllowed = (context, userId)=>organizationStoreFor(context).transaction(async (tx)=>{
+        if ((await tx.find('organizations', {
+            ownerUserId: requireIdentifier(userId.replace(/^users\//, ''))
+        })).length) {
+            throw new Error('ownership_transfer_required');
+        }
+    });
+export const listOrganizationMembers = (context, organizationId)=>organizationStoreFor(context).transaction(async (tx)=>{
+        await organizationAccessInTransaction(tx, context, organizationId, 'member');
+        return tx.find('organizationMemberships', {
+            organizationId
+        });
+    }); /* ArangoDB document metadata uses these reserved field names. */  /* eslint no-underscore-dangle: ["warn", {"allow": ["_key", "_rev", "_id"]}] */ 
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/organizations/membership.ts"],"sourcesContent":["import {randomBytes} from 'node:crypto';\n\nimport {organizationAccessInTransaction, organizationUserId} from './authorization.js';\nimport {\n  newOrganizationId,\n  organizationKey,\n  organizationStoreFor,\n  requireIdentifier,\n  type OrganizationTransaction,\n  type Stored\n} from './store.js';\n\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {\n  BillingJob,\n  MembershipChange,\n  Organization,\n  OrganizationMembership,\n  SeatChangeQuote\n} from './types.js';\n\nexport const activeMemberCount = async (\n  tx: OrganizationTransaction,\n  organizationId: string\n): Promise<number> =>\n  (await tx.find<OrganizationMembership>('organizationMemberships', {organizationId, status: 'active'}))\n    .length;\n\nexport const writeSeatChange = async (\n  tx: OrganizationTransaction,\n  org: Stored<Organization>,\n  quantity: number,\n  effectiveAt: number,\n  previousQuantity: number\n): Promise<void> => {\n  const revision = org.revision + 1;\n  await tx.put('organizations', org.organizationId, {...org, revision, updatedAt: effectiveAt}, org);\n  const jobId = organizationKey(org.organizationId, String(revision));\n  const job: BillingJob = {\n    attempts: 0,\n    desired: {extraSeats: Math.max(0, quantity - 10), previousExtraSeats: Math.max(0, previousQuantity - 10)},\n    effectiveAt,\n    jobId,\n    kind: 'seats',\n    leaseExpires: 0,\n    organizationId: org.organizationId,\n    owner: '',\n    priceVersion: '2026-10-v1',\n    sequence: revision,\n    status: 'pending'\n  };\n  await tx.put('organizationBillingJobs', jobId, job);\n};\n\nexport const validateSeatQuote = async (\n  tx: OrganizationTransaction,\n  org: Organization,\n  change: MembershipChange,\n  quantity: number\n): Promise<void> => {\n  const quote = change.confirmedQuoteId\n    ? await tx.get<\n        SeatChangeQuote & {\n          expectedRevision: number;\n          organizationId: string;\n          role: string;\n          userId: string;\n          status: string;\n          used: boolean;\n        }\n    >('organizationBillingQuotes', change.confirmedQuoteId)\n    : null;\n  if(\n    !quote ||\n    quote.used ||\n    quote.organizationRevision !== org.revision ||\n    quote.organizationId !== org.organizationId ||\n    quote.expectedRevision !== change.expectedRevision ||\n    quote.role !== change.role ||\n    quote.expiresAt <= Date.now() ||\n    quote.userId !== change.userId ||\n    quote.status !== change.status ||\n    quote.quantity !== quantity\n  ) {\n    throw new Error('seat_quote_required');\n  }\n  await tx.put('organizationBillingQuotes', quote._key, {...quote, used: true}, quote);\n};\n\nexport const changeOrganizationMember = (\n  context: ApiContext,\n  organizationId: string,\n  change: MembershipChange\n): Promise<OrganizationMembership> =>\n  organizationStoreFor(context).transaction(async (tx) => {\n    const access = await organizationAccessInTransaction(tx, context, organizationId, 'admin');\n    const org = await tx.get<Organization>('organizations', organizationId);\n    const member = await tx.get<OrganizationMembership>(\n      'organizationMemberships',\n      organizationKey(organizationId, requireIdentifier(change.userId))\n    );\n    if(\n      !['admin', 'member'].includes(change.role) ||\n      !['active', 'deactivated'].includes(change.status) ||\n      !Number.isSafeInteger(change.expectedRevision)\n    ) {\n      throw new Error('invalid_membership');\n    }\n    if(!org || !member || member.revision !== change.expectedRevision) {\n      throw new Error('revision_conflict');\n    }\n    if(\n      access.organization.ownerUserId === member.userId &&\n      (change.role !== 'admin' || change.status !== 'active')\n    ) {\n      throw new Error('ownership_transfer_required');\n    }\n    const user = await tx.get<{active: boolean; verifiedEmail: boolean}>('users', member.userId);\n    if(change.status === 'active' && (!user?.active || !user.verifiedEmail)) {\n      throw new Error('verified_active_user_required');\n    }\n    const count = await activeMemberCount(tx, organizationId);\n    const nextCount = count + Number(change.status === 'active') - Number(member.status === 'active');\n    const billing = await tx.get<{plan?: string; status?: string}>('organizationBilling', organizationId);\n    if(nextCount > count && nextCount > 10 && billing?.plan) {\n      if(billing.status !== 'active') {\n        throw new Error('billing_not_ready');\n      }\n      await validateSeatQuote(tx, org, change, Math.max(0, nextCount - 10));\n    }\n    const now = Date.now();\n    const updated = {\n      ...member,\n      revision: member.revision + 1,\n      role: change.role,\n      status: change.status,\n      updatedAt: now\n    };\n    await tx.put('organizationMemberships', member._key, updated, member);\n    await writeSeatChange(tx, org, nextCount, now, count);\n    return updated;\n  });\n\ntype Transfer = {\n  expiresAt: number;\n  organizationId: string;\n  ownerUserId: string;\n  recipientUserId: string;\n  revision: number;\n  used: boolean;\n};\nexport const requestOwnershipTransfer = (\n  context: ApiContext,\n  organizationId: string,\n  recipientUserId: string\n): Promise<{transferId: string}> =>\n  organizationStoreFor(context).transaction(async (tx) => {\n    const {organization} = await organizationAccessInTransaction(tx, context, organizationId, 'owner');\n    const recipient = await tx.get<OrganizationMembership>(\n      'organizationMemberships',\n      organizationKey(organizationId, requireIdentifier(recipientUserId))\n    );\n    if(!recipient || recipient.status !== 'active' || recipientUserId === organization.ownerUserId) {\n      throw new Error('active_recipient_required');\n    }\n    const transferId = newOrganizationId();\n    await tx.put('organizationOwnerTransfers', transferId, {\n      expiresAt: Date.now() + (48 * 3600000),\n      organizationId,\n      ownerUserId: organization.ownerUserId,\n      recipientUserId,\n      revision: organization.revision,\n      used: false\n    });\n    return {transferId};\n  });\n\nexport const acceptOwnershipTransfer = (context: ApiContext, transferId: string): Promise<Organization> =>\n  organizationStoreFor(context).transaction(async (tx) => {\n    const transfer = await tx.get<Transfer>('organizationOwnerTransfers', requireIdentifier(transferId));\n    if(\n      !transfer ||\n      transfer.used ||\n      transfer.expiresAt <= Date.now() ||\n      transfer.recipientUserId !== organizationUserId(context)\n    ) {\n      throw new Error('invalid_transfer');\n    }\n    const access = await organizationAccessInTransaction(tx, context, transfer.organizationId, 'member');\n    const org = await tx.get<Organization>('organizations', transfer.organizationId);\n    const member = await tx.get<OrganizationMembership>(\n      'organizationMemberships',\n      organizationKey(transfer.organizationId, access.userId)\n    );\n    if(!org || !member || org.ownerUserId !== transfer.ownerUserId || org.revision !== transfer.revision) {\n      throw new Error('invalid_transfer');\n    }\n    const now = Date.now();\n    const updated = {...org, ownerUserId: access.userId, revision: org.revision + 1, updatedAt: now};\n    await tx.put('organizations', org._key, updated, org);\n    await tx.put(\n      'organizationMemberships',\n      member._key,\n      {...member, revision: member.revision + 1, role: 'admin', updatedAt: now},\n      member\n    );\n    await tx.put('organizationOwnerTransfers', transfer._key, {...transfer, used: true}, transfer);\n    const user = await tx.get('users', access.userId);\n    if(!user) {\n      throw new Error('organization_state_invalid');\n    }\n    await tx.put('users', access.userId, {...user, organizationAccount: true}, user);\n    return updated;\n  });\n\ntype Invitation = {\n  email: string;\n  expiresAt: number;\n  invitedBy: string;\n  organizationId: string;\n  revoked: boolean;\n  tokenHash: string;\n  used: boolean;\n};\nexport const inviteOrganizationMember = (\n  context: ApiContext,\n  organizationId: string,\n  email: string,\n  acceptsAdditionalSeatCharge: boolean\n): Promise<{invitationId: string; token: string}> =>\n  organizationStoreFor(context).transaction(async (tx) => {\n    const access = await organizationAccessInTransaction(tx, context, organizationId, 'admin');\n    const normalized = email.trim().toLowerCase();\n    if(!/^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(normalized) || !acceptsAdditionalSeatCharge) {\n      throw new Error('invitation_charge_disclosure_required');\n    }\n    const existing = (\n      await tx.find<Invitation>('organizationInvitations', {email: normalized, organizationId})\n    ).find((invitation) => !invitation.used && !invitation.revoked && invitation.expiresAt > Date.now());\n    if(existing) {\n      throw new Error('invitation_exists');\n    }\n    const invitationId = newOrganizationId();\n    const token = randomBytes(32).toString('base64url');\n    await tx.put('organizationInvitations', invitationId, {\n      email: normalized,\n      expiresAt: Date.now() + (7 * 86400000),\n      invitedBy: access.userId,\n      organizationId,\n      revoked: false,\n      tokenHash: organizationKey(token),\n      used: false\n    });\n    return {invitationId, token};\n  });\n\nexport const acceptOrganizationInvitation = (\n  context: ApiContext,\n  invitationId: string,\n  token: string\n): Promise<OrganizationMembership> =>\n  organizationStoreFor(context).transaction(async (tx) => {\n    const userId = organizationUserId(context);\n    const invitation = await tx.get<Invitation>('organizationInvitations', requireIdentifier(invitationId));\n    const user = await tx.get<{active: boolean; email: string; verifiedEmail: boolean}>('users', userId);\n    if(\n      !invitation ||\n      invitation.revoked ||\n      invitation.used ||\n      invitation.expiresAt <= Date.now() ||\n      invitation.tokenHash !== organizationKey(token) ||\n      !user?.active ||\n      !user.verifiedEmail ||\n      user.email.toLowerCase() !== invitation.email\n    ) {\n      throw new Error('invalid_invitation');\n    }\n    await organizationAccessInTransaction(\n      tx,\n      {session: {userId: invitation.invitedBy}},\n      invitation.organizationId,\n      'admin'\n    );\n    const org = await tx.get<Organization>('organizations', invitation.organizationId);\n    if(!org) {\n      throw new Error('organization_access_denied');\n    }\n    const key = organizationKey(invitation.organizationId, userId);\n    const previous = await tx.get<OrganizationMembership>('organizationMemberships', key);\n    if(previous?.status === 'active') {\n      throw new Error('already_active');\n    }\n    const now = Date.now();\n    const member: OrganizationMembership = {\n      createdAt: previous?.createdAt || now,\n      organizationId: org.organizationId,\n      revision: (previous?.revision || 0) + 1,\n      role: previous?.role || 'member',\n      status: 'active',\n      updatedAt: now,\n      userId\n    };\n    const previousCount = await activeMemberCount(tx, org.organizationId);\n    const billing = await tx.get<{plan?: string; status?: string}>('organizationBilling', org.organizationId);\n    if(previousCount >= 10 && billing?.plan && billing.status !== 'active') {\n      throw new Error('billing_not_ready');\n    }\n    await tx.put('organizationMemberships', key, member, previous);\n    await tx.put('users', userId, {...user, organizationAccount: true}, user);\n    await writeSeatChange(tx, org, previousCount + 1, now, previousCount);\n    await tx.put('organizationInvitations', invitationId, {...invitation, used: true}, invitation);\n    return member;\n  });\n\nexport const revokeOrganizationInvitation = (context: ApiContext, invitationId: string): Promise<void> =>\n  organizationStoreFor(context).transaction(async (tx) => {\n    const invitation = await tx.get<Invitation>('organizationInvitations', requireIdentifier(invitationId));\n    if(!invitation) {\n      throw new Error('invalid_invitation');\n    }\n    await organizationAccessInTransaction(tx, context, invitation.organizationId, 'admin');\n    await tx.put('organizationInvitations', invitationId, {...invitation, revoked: true}, invitation);\n  });\n\nexport const assertOrganizationAccountRemovalAllowed = (context: ApiContext, userId: string): Promise<void> =>\n  organizationStoreFor(context).transaction(async (tx) => {\n    if(\n      (\n        await tx.find<Organization>('organizations', {\n          ownerUserId: requireIdentifier(userId.replace(/^users\\//, ''))\n        })\n      ).length\n    ) {\n      throw new Error('ownership_transfer_required');\n    }\n  });\n\nexport const listOrganizationMembers = (\n  context: ApiContext,\n  organizationId: string\n): Promise<OrganizationMembership[]> =>\n  organizationStoreFor(context).transaction(async (tx) => {\n    await organizationAccessInTransaction(tx, context, organizationId, 'member');\n    return tx.find<OrganizationMembership>('organizationMemberships', {organizationId});\n  });\n/* ArangoDB document metadata uses these reserved field names. */\n/* eslint no-underscore-dangle: [\"warn\", {\"allow\": [\"_key\", \"_rev\", \"_id\"]}] */\n"],"names":["randomBytes","organizationAccessInTransaction","organizationUserId","newOrganizationId","organizationKey","organizationStoreFor","requireIdentifier","activeMemberCount","tx","organizationId","find","status","length","writeSeatChange","org","quantity","effectiveAt","previousQuantity","revision","put","updatedAt","jobId","String","job","attempts","desired","extraSeats","Math","max","previousExtraSeats","kind","leaseExpires","owner","priceVersion","sequence","validateSeatQuote","change","quote","confirmedQuoteId","get","used","organizationRevision","expectedRevision","role","expiresAt","Date","now","userId","Error","_key","changeOrganizationMember","context","transaction","access","member","includes","Number","isSafeInteger","organization","ownerUserId","user","active","verifiedEmail","count","nextCount","billing","plan","updated","requestOwnershipTransfer","recipientUserId","recipient","transferId","acceptOwnershipTransfer","transfer","organizationAccount","inviteOrganizationMember","email","acceptsAdditionalSeatCharge","normalized","trim","toLowerCase","test","existing","invitation","revoked","invitationId","token","toString","invitedBy","tokenHash","acceptOrganizationInvitation","session","key","previous","createdAt","previousCount","revokeOrganizationInvitation","assertOrganizationAccountRemovalAllowed","replace","listOrganizationMembers"],"mappings":"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"}

package/lib/organizations/passwordRecovery.d.ts

@@ -0,0 +1,9 @@
+import type { ApiContext } from '../types/auth.types.js';
+/** Internal recovery capability. Never exposed through generic profile updates. */
+export declare const organizationPasswordRecovery: (context: ApiContext, userId: string, operation: 'consume' | 'issue', input: Readonly<{
+    code: number;
+    email?: string;
+    expires?: number;
+    password?: string;
+    phone?: string;
+}>) => Promise<boolean | null>;

package/lib/organizations/passwordRecovery.js

@@ -0,0 +1,50 @@
+import { createPassword, parsePassword } from '@nlabs/utils/parsers/strings';
+import { organizationStoreFor } from './store.js';
+/** Internal recovery capability. Never exposed through generic profile updates. */ export const organizationPasswordRecovery = async (context, userId, operation, input)=>{
+    if (!process.env.ARANGODB_DATABASE || context.databaseName !== process.env.ARANGODB_DATABASE) {
+        return null;
+    }
+    const key = userId.replace(/^users\//, '');
+    return organizationStoreFor(context).transaction(async (tx)=>{
+        const user = await tx.get('users', key);
+        const memberships = await tx.find('organizationMemberships', {
+            userId: key
+        });
+        const owners = await tx.find('organizations', {
+            ownerUserId: key
+        });
+        if (!user || !user.organizationAccount && !memberships.length && !owners.length) {
+            return null;
+        }
+        const email = Boolean(input.email && user.verifiedEmail && user.email === input.email);
+        const phone = Boolean(input.phone && user.verifiedPhone && user.phone === input.phone);
+        if (!user.active || !email && !phone || !Number.isSafeInteger(input.code) || input.code < 100000 || input.code > 999999) {
+            return false;
+        }
+        const codeField = phone ? 'verifiedSmsCode' : 'verifiedEmailCode';
+        const expiryField = phone ? 'verifiedPhoneExpires' : 'verifiedEmailExpires';
+        if (operation === 'issue') {
+            if (!Number.isSafeInteger(input.expires) || input.expires <= Date.now() || input.expires > Date.now() + 900000) {
+                return false;
+            }
+            await tx.put('users', key, {
+                ...user,
+                [codeField]: input.code,
+                [expiryField]: input.expires
+            }, user);
+            return true;
+        }
+        if (user[codeField] !== input.code || Number(user[expiryField] || 0) <= Date.now() || !input.password || !user.salt) {
+            return false;
+        }
+        await tx.put('users', key, {
+            ...user,
+            [codeField]: 0,
+            [expiryField]: 0,
+            password: createPassword(parsePassword(input.password), user.salt)
+        }, user);
+        return true;
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/organizations/plans.d.ts

@@ -0,0 +1,6 @@
+import type { OrganizationPlan, PlanKey } from './types.js';
+export declare const getOrganizationPlan: (plan: PlanKey) => OrganizationPlan;
+export declare const calculateSeatCharge: (plan: PlanKey, activeMembers: number) => {
+    extraSeats: number;
+    monthlyCents: number;
+};

package/lib/organizations/plans.js

@@ -0,0 +1,40 @@
+const catalog = Object.freeze({
+    pro: Object.freeze({
+        additionalSeatCents: 800,
+        baseCents: 14900,
+        currency: 'usd',
+        includedSeats: 10,
+        interval: 'month',
+        key: 'pro',
+        version: '2026-10-v1'
+    }),
+    starter: Object.freeze({
+        additionalSeatCents: 800,
+        baseCents: 4900,
+        currency: 'usd',
+        includedSeats: 10,
+        interval: 'month',
+        key: 'starter',
+        version: '2026-10-v1'
+    })
+});
+export const getOrganizationPlan = (plan)=>{
+    if (plan !== 'starter' && plan !== 'pro') {
+        throw new Error('invalid_plan');
+    }
+    return catalog[plan];
+};
+export const calculateSeatCharge = (plan, activeMembers)=>{
+    const config = getOrganizationPlan(plan);
+    const extraSeats = Math.max(0, activeMembers - config.includedSeats);
+    const monthlyCents = config.baseCents + extraSeats * config.additionalSeatCents;
+    if (!Number.isSafeInteger(activeMembers) || activeMembers < 0 || !Number.isSafeInteger(monthlyCents)) {
+        throw new Error('invalid_member_count');
+    }
+    return {
+        extraSeats,
+        monthlyCents
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/organizations/providerPagination.d.ts

@@ -0,0 +1,6 @@
+export declare const listAllProviderRecords: <T extends {
+    id: string;
+}>(load: (after?: string) => Promise<{
+    data: T[];
+    has_more: boolean;
+}>) => Promise<T[]>;

package/lib/organizations/providerPagination.js

@@ -0,0 +1,23 @@
+/* Each provider page requires the previous page's cursor; incomplete recovery must fail closed. */ /* eslint-disable no-await-in-loop */ export const listAllProviderRecords = async (load)=>{
+    let after;
+    const records = [];
+    const seen = new Set();
+    for(let page = 0; page < 100; page++){
+        const response = await load(after);
+        if (response.data.some((record)=>seen.has(record.id)) || new Set(response.data.map((record)=>record.id)).size !== response.data.length) {
+            throw new Error('billing_lookup_incomplete');
+        }
+        response.data.forEach((record)=>seen.add(record.id));
+        records.push(...response.data);
+        if (!response.has_more) {
+            return records;
+        }
+        if (!response.data.length) {
+            throw new Error('billing_lookup_incomplete');
+        }
+        after = response.data.at(-1).id;
+    }
+    throw new Error('billing_lookup_incomplete');
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/organizations/reconciliation.d.ts

@@ -0,0 +1,11 @@
+import type { ApiContext } from '../types/auth.types.js';
+import type { OveragePreference, PlanKey, SeatChangeQuote, SubscriptionSummary, VerifiedBillingEvent } from './types.js';
+export declare const reconcileOrganizationBillingEvent: (context: ApiContext, event: VerifiedBillingEvent) => Promise<void>;
+export declare const processOrganizationBillingJobs: (context: ApiContext, limit: number) => Promise<{
+    completed: number;
+    pending: number;
+}>;
+export declare const quoteOrganizationPlanChange: (context: ApiContext, organizationId: string, plan: PlanKey) => Promise<SeatChangeQuote>;
+export declare const changeOrganizationPlan: (context: ApiContext, organizationId: string, plan: PlanKey, confirmedQuoteId: string) => Promise<SubscriptionSummary>;
+export declare const cancelOrganizationSubscription: (context: ApiContext, organizationId: string) => Promise<SubscriptionSummary>;
+export declare const setOrganizationOveragePreference: (context: ApiContext, organizationId: string, preference: OveragePreference) => Promise<SubscriptionSummary>;