@shipfox/api-workspaces 2.0.0

package/dist/db/db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/db/db.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAOnE,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKlB,CAAC;AAIF,wBAAgB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGjB;AAED,wBAAgB,OAAO,IAAI,IAAI,CAE9B"}

package/dist/db/db.js

@@ -0,0 +1,24 @@
+import { drizzle } from '@shipfox/node-drizzle';
+import { pgClient } from '@shipfox/node-postgres';
+import { invitations } from './schema/invitations.js';
+import { memberships } from './schema/memberships.js';
+import { workspacesOutbox } from './schema/outbox.js';
+import { workspaces } from './schema/workspaces.js';
+export const schema = {
+    workspaces,
+    memberships,
+    invitations,
+    workspacesOutbox
+};
+let _db;
+export function db() {
+    if (!_db) _db = drizzle(pgClient(), {
+        schema
+    });
+    return _db;
+}
+export function closeDb() {
+    _db = undefined;
+}
+
+//# sourceMappingURL=db.js.map

package/dist/db/db.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/db.ts"],"sourcesContent":["import {drizzle, type NodePgDatabase} from '@shipfox/node-drizzle';\nimport {pgClient} from '@shipfox/node-postgres';\nimport {invitations} from './schema/invitations.js';\nimport {memberships} from './schema/memberships.js';\nimport {workspacesOutbox} from './schema/outbox.js';\nimport {workspaces} from './schema/workspaces.js';\n\nexport const schema = {\n  workspaces,\n  memberships,\n  invitations,\n  workspacesOutbox,\n};\n\nlet _db: NodePgDatabase<typeof schema> | undefined;\n\nexport function db() {\n  if (!_db) _db = drizzle(pgClient(), {schema});\n  return _db;\n}\n\nexport function closeDb(): void {\n  _db = undefined;\n}\n"],"names":["drizzle","pgClient","invitations","memberships","workspacesOutbox","workspaces","schema","_db","db","closeDb","undefined"],"mappings":"AAAA,SAAQA,OAAO,QAA4B,wBAAwB;AACnE,SAAQC,QAAQ,QAAO,yBAAyB;AAChD,SAAQC,WAAW,QAAO,0BAA0B;AACpD,SAAQC,WAAW,QAAO,0BAA0B;AACpD,SAAQC,gBAAgB,QAAO,qBAAqB;AACpD,SAAQC,UAAU,QAAO,yBAAyB;AAElD,OAAO,MAAMC,SAAS;IACpBD;IACAF;IACAD;IACAE;AACF,EAAE;AAEF,IAAIG;AAEJ,OAAO,SAASC;IACd,IAAI,CAACD,KAAKA,MAAMP,QAAQC,YAAY;QAACK;IAAM;IAC3C,OAAOC;AACT;AAEA,OAAO,SAASE;IACdF,MAAMG;AACR"}

package/dist/db/index.d.ts

@@ -0,0 +1,10 @@
+export { closeDb, db, schema } from './db.js';
+export type { AcceptInvitationParams, AcceptInvitationResult, CreateInvitationParams, } from './invitations.js';
+export { acceptInvitation, createInvitation, findInvitationByToken, listOpenInvitationsByWorkspace, revokeInvitation, } from './invitations.js';
+export type { CreateMembershipParams, MembershipWithUser, MembershipWithWorkspace, RemoveMembershipParams, } from './memberships.js';
+export { createMembership, findMembership, listMembershipsByUser, listMembershipsByWorkspace, removeMembership, } from './memberships.js';
+export { workspacesOutbox } from './schema/outbox.js';
+export type { CreateWorkspaceParams, UpdateWorkspaceParams, WorkspaceServiceMetrics, } from './workspaces.js';
+export { createWorkspace, getWorkspaceById, getWorkspaceServiceMetrics, updateWorkspace, } from './workspaces.js';
+export declare const migrationsPath: string;
+//# sourceMappingURL=index.d.ts.map

package/dist/db/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/db/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,OAAO,EAAE,EAAE,EAAE,MAAM,EAAC,MAAM,SAAS,CAAC;AAC5C,YAAY,EACV,sBAAsB,EACtB,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,qBAAqB,EACrB,8BAA8B,EAC9B,gBAAgB,GACjB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,sBAAsB,EACtB,kBAAkB,EAClB,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,qBAAqB,EACrB,0BAA0B,EAC1B,gBAAgB,GACjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAC;AACpD,YAAY,EACV,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,GACxB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,0BAA0B,EAC1B,eAAe,GAChB,MAAM,iBAAiB,CAAC;AAEzB,eAAO,MAAM,cAAc,QAAoE,CAAC"}

package/dist/db/index.js

@@ -0,0 +1,10 @@
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export { closeDb, db, schema } from './db.js';
+export { acceptInvitation, createInvitation, findInvitationByToken, listOpenInvitationsByWorkspace, revokeInvitation } from './invitations.js';
+export { createMembership, findMembership, listMembershipsByUser, listMembershipsByWorkspace, removeMembership } from './memberships.js';
+export { workspacesOutbox } from './schema/outbox.js';
+export { createWorkspace, getWorkspaceById, getWorkspaceServiceMetrics, updateWorkspace } from './workspaces.js';
+export const migrationsPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../drizzle');
+
+//# sourceMappingURL=index.js.map

package/dist/db/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/index.ts"],"sourcesContent":["import {dirname, resolve} from 'node:path';\nimport {fileURLToPath} from 'node:url';\n\nexport {closeDb, db, schema} from './db.js';\nexport type {\n  AcceptInvitationParams,\n  AcceptInvitationResult,\n  CreateInvitationParams,\n} from './invitations.js';\nexport {\n  acceptInvitation,\n  createInvitation,\n  findInvitationByToken,\n  listOpenInvitationsByWorkspace,\n  revokeInvitation,\n} from './invitations.js';\nexport type {\n  CreateMembershipParams,\n  MembershipWithUser,\n  MembershipWithWorkspace,\n  RemoveMembershipParams,\n} from './memberships.js';\nexport {\n  createMembership,\n  findMembership,\n  listMembershipsByUser,\n  listMembershipsByWorkspace,\n  removeMembership,\n} from './memberships.js';\nexport {workspacesOutbox} from './schema/outbox.js';\nexport type {\n  CreateWorkspaceParams,\n  UpdateWorkspaceParams,\n  WorkspaceServiceMetrics,\n} from './workspaces.js';\nexport {\n  createWorkspace,\n  getWorkspaceById,\n  getWorkspaceServiceMetrics,\n  updateWorkspace,\n} from './workspaces.js';\n\nexport const migrationsPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../drizzle');\n"],"names":["dirname","resolve","fileURLToPath","closeDb","db","schema","acceptInvitation","createInvitation","findInvitationByToken","listOpenInvitationsByWorkspace","revokeInvitation","createMembership","findMembership","listMembershipsByUser","listMembershipsByWorkspace","removeMembership","workspacesOutbox","createWorkspace","getWorkspaceById","getWorkspaceServiceMetrics","updateWorkspace","migrationsPath","url"],"mappings":"AAAA,SAAQA,OAAO,EAAEC,OAAO,QAAO,YAAY;AAC3C,SAAQC,aAAa,QAAO,WAAW;AAEvC,SAAQC,OAAO,EAAEC,EAAE,EAAEC,MAAM,QAAO,UAAU;AAM5C,SACEC,gBAAgB,EAChBC,gBAAgB,EAChBC,qBAAqB,EACrBC,8BAA8B,EAC9BC,gBAAgB,QACX,mBAAmB;AAO1B,SACEC,gBAAgB,EAChBC,cAAc,EACdC,qBAAqB,EACrBC,0BAA0B,EAC1BC,gBAAgB,QACX,mBAAmB;AAC1B,SAAQC,gBAAgB,QAAO,qBAAqB;AAMpD,SACEC,eAAe,EACfC,gBAAgB,EAChBC,0BAA0B,EAC1BC,eAAe,QACV,kBAAkB;AAEzB,OAAO,MAAMC,iBAAiBpB,QAAQD,QAAQE,cAAc,YAAYoB,GAAG,IAAI,iBAAiB"}

package/dist/db/invitations.d.ts

@@ -0,0 +1,47 @@
+import type { Invitation } from '#core/entities/invitation.js';
+import type { Membership } from '#core/entities/membership.js';
+interface CreateInvitationBaseParams {
+    workspaceId: string;
+    email: string;
+    hashedToken: string;
+    expiresAt: Date;
+    invitedByUserId: string;
+    invitedByDisplay?: string | null;
+}
+export type CreateInvitationParams = CreateInvitationBaseParams & ({
+    sendEmail: {
+        workspaceName: string;
+        inviterName: string;
+        inviteLink: string;
+    };
+    skipEmail?: never;
+} | {
+    sendEmail?: never;
+    skipEmail: true;
+});
+export declare function createInvitation(params: CreateInvitationParams): Promise<Invitation>;
+export declare function findInvitationByToken(params: {
+    hashedToken: string;
+}): Promise<Invitation | undefined>;
+export declare function findInvitationById(params: {
+    id: string;
+}): Promise<Invitation | undefined>;
+export declare function listOpenInvitationsByWorkspace(params: {
+    workspaceId: string;
+}): Promise<Invitation[]>;
+export declare function revokeInvitation(params: {
+    invitationId: string;
+}): Promise<void>;
+export interface AcceptInvitationParams {
+    invitationId: string;
+    acceptedByUserId: string;
+    acceptedByUserName?: string | null | undefined;
+}
+export interface AcceptInvitationResult {
+    invitation: Invitation;
+    membership: Membership;
+    alreadyMember: boolean;
+}
+export declare function acceptInvitation(params: AcceptInvitationParams): Promise<AcceptInvitationResult | undefined>;
+export {};
+//# sourceMappingURL=invitations.d.ts.map

package/dist/db/invitations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invitations.d.ts","sourceRoot":"","sources":["../../src/db/invitations.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,8BAA8B,CAAC;AAC7D,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,8BAA8B,CAAC;AAa7D,UAAU,0BAA0B;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,IAAI,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AAED,MAAM,MAAM,sBAAsB,GAAG,0BAA0B,GAC7D,CACI;IACE,SAAS,EAAE;QACT,aAAa,EAAE,MAAM,CAAC;QACtB,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,SAAS,CAAC,EAAE,KAAK,CAAC;CACnB,GACD;IAAC,SAAS,CAAC,EAAE,KAAK,CAAC;IAAC,SAAS,EAAE,IAAI,CAAA;CAAC,CACvC,CAAC;AAEJ,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,UAAU,CAAC,CA4D1F;AAED,wBAAsB,qBAAqB,CAAC,MAAM,EAAE;IAClD,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAUlC;AAED,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAAC,EAAE,EAAE,MAAM,CAAA;CAAC,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAM9F;AAED,wBAAsB,8BAA8B,CAAC,MAAM,EAAE;IAC3D,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAaxB;AAED,wBAAsB,gBAAgB,CAAC,MAAM,EAAE;IAAC,YAAY,EAAE,MAAM,CAAA;CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAEpF;AAED,MAAM,WAAW,sBAAsB;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CAChD;AAED,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,UAAU,CAAC;IACvB,UAAU,EAAE,UAAU,CAAC;IACvB,aAAa,EAAE,OAAO,CAAC;CACxB;AAED,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,sBAAsB,GAC7B,OAAO,CAAC,sBAAsB,GAAG,SAAS,CAAC,CAyE7C"}

package/dist/db/invitations.js

@@ -0,0 +1,107 @@
+import { WORKSPACES_INVITATION_SEND_REQUESTED } from '@shipfox/api-workspaces-dto';
+import { writeOutboxEvent } from '@shipfox/node-outbox';
+import { and, eq, gt, isNull, lt, sql } from 'drizzle-orm';
+import { OpenInvitationExistsError } from '#core/errors.js';
+import { recordWorkspaceInvitationAccepted, recordWorkspaceInvitationCreated, recordWorkspaceMembershipChanged } from '#metrics/instance.js';
+import { db } from './db.js';
+import { membershipValues } from './memberships.js';
+import { invitations, toInvitation } from './schema/invitations.js';
+import { memberships, toMembership } from './schema/memberships.js';
+import { workspacesOutbox } from './schema/outbox.js';
+export async function createInvitation(params) {
+    const result = await db().transaction(async (tx)=>{
+        await tx.delete(invitations).where(and(eq(invitations.workspaceId, params.workspaceId), eq(invitations.email, params.email), isNull(invitations.acceptedAt), lt(invitations.expiresAt, sql`now()`)));
+        const open = await tx.select().from(invitations).where(and(eq(invitations.workspaceId, params.workspaceId), eq(invitations.email, params.email), isNull(invitations.acceptedAt))).limit(1);
+        if (open.length > 0) {
+            throw new OpenInvitationExistsError(params.email);
+        }
+        const rows = await tx.insert(invitations).values({
+            workspaceId: params.workspaceId,
+            email: params.email,
+            hashedToken: params.hashedToken,
+            expiresAt: params.expiresAt,
+            invitedByUserId: params.invitedByUserId,
+            invitedByDisplay: params.invitedByDisplay ?? null
+        }).returning();
+        const row = rows[0];
+        if (!row) throw new Error('Insert returned no rows');
+        if (params.sendEmail) {
+            await writeOutboxEvent(tx, workspacesOutbox, {
+                type: WORKSPACES_INVITATION_SEND_REQUESTED,
+                payload: {
+                    email: params.email,
+                    ...params.sendEmail
+                }
+            });
+        }
+        return {
+            invitation: toInvitation(row),
+            emailRequested: params.sendEmail ? 'requested' : 'skipped'
+        };
+    });
+    recordWorkspaceInvitationCreated(result.emailRequested);
+    return result.invitation;
+}
+export async function findInvitationByToken(params) {
+    const rows = await db().select().from(invitations).where(eq(invitations.hashedToken, params.hashedToken)).limit(1);
+    const row = rows[0];
+    if (!row) return undefined;
+    return toInvitation(row);
+}
+export async function findInvitationById(params) {
+    const rows = await db().select().from(invitations).where(eq(invitations.id, params.id)).limit(1);
+    const row = rows[0];
+    if (!row) return undefined;
+    return toInvitation(row);
+}
+export async function listOpenInvitationsByWorkspace(params) {
+    const rows = await db().select().from(invitations).where(and(eq(invitations.workspaceId, params.workspaceId), isNull(invitations.acceptedAt), gt(invitations.expiresAt, sql`now()`)));
+    return rows.map(toInvitation);
+}
+export async function revokeInvitation(params) {
+    await db().delete(invitations).where(eq(invitations.id, params.invitationId));
+}
+export async function acceptInvitation(params) {
+    const result = await db().transaction(async (tx)=>{
+        const inv = await tx.select().from(invitations).where(and(eq(invitations.id, params.invitationId), isNull(invitations.acceptedAt), gt(invitations.expiresAt, sql`now()`))).limit(1);
+        const invRow = inv[0];
+        if (!invRow) return undefined;
+        const existing = await tx.select().from(memberships).where(and(eq(memberships.userId, params.acceptedByUserId), eq(memberships.workspaceId, invRow.workspaceId))).limit(1);
+        let membership;
+        let alreadyMember = false;
+        const existingRow = existing[0];
+        if (existingRow) {
+            alreadyMember = true;
+            membership = toMembership(existingRow);
+        } else {
+            const created = await tx.insert(memberships).values(membershipValues({
+                userId: params.acceptedByUserId,
+                userEmail: invRow.email,
+                userName: params.acceptedByUserName ?? null,
+                workspaceId: invRow.workspaceId
+            })).returning();
+            const createdRow = created[0];
+            if (!createdRow) throw new Error('Insert returned no rows');
+            membership = toMembership(createdRow);
+        }
+        const updated = await tx.update(invitations).set({
+            acceptedAt: sql`now()`,
+            acceptedByUserId: params.acceptedByUserId,
+            updatedAt: sql`now()`
+        }).where(eq(invitations.id, params.invitationId)).returning();
+        const updatedRow = updated[0];
+        if (!updatedRow) throw new Error('Update returned no rows');
+        return {
+            invitation: toInvitation(updatedRow),
+            membership,
+            alreadyMember
+        };
+    });
+    if (result && !result.alreadyMember) recordWorkspaceMembershipChanged('added');
+    if (result) {
+        recordWorkspaceInvitationAccepted(result.alreadyMember ? 'already_member' : 'added');
+    }
+    return result;
+}
+
+//# sourceMappingURL=invitations.js.map

package/dist/db/invitations.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/invitations.ts"],"sourcesContent":["import {\n  WORKSPACES_INVITATION_SEND_REQUESTED,\n  type WorkspacesEventMap,\n} from '@shipfox/api-workspaces-dto';\nimport {writeOutboxEvent} from '@shipfox/node-outbox';\nimport {and, eq, gt, isNull, lt, sql} from 'drizzle-orm';\nimport type {Invitation} from '#core/entities/invitation.js';\nimport type {Membership} from '#core/entities/membership.js';\nimport {OpenInvitationExistsError} from '#core/errors.js';\nimport {\n  recordWorkspaceInvitationAccepted,\n  recordWorkspaceInvitationCreated,\n  recordWorkspaceMembershipChanged,\n} from '#metrics/instance.js';\nimport {db} from './db.js';\nimport {membershipValues} from './memberships.js';\nimport {invitations, toInvitation} from './schema/invitations.js';\nimport {memberships, toMembership} from './schema/memberships.js';\nimport {workspacesOutbox} from './schema/outbox.js';\n\ninterface CreateInvitationBaseParams {\n  workspaceId: string;\n  email: string;\n  hashedToken: string;\n  expiresAt: Date;\n  invitedByUserId: string;\n  invitedByDisplay?: string | null;\n}\n\nexport type CreateInvitationParams = CreateInvitationBaseParams &\n  (\n    | {\n        sendEmail: {\n          workspaceName: string;\n          inviterName: string;\n          inviteLink: string;\n        };\n        skipEmail?: never;\n      }\n    | {sendEmail?: never; skipEmail: true}\n  );\n\nexport async function createInvitation(params: CreateInvitationParams): Promise<Invitation> {\n  const result = await db().transaction(async (tx) => {\n    await tx\n      .delete(invitations)\n      .where(\n        and(\n          eq(invitations.workspaceId, params.workspaceId),\n          eq(invitations.email, params.email),\n          isNull(invitations.acceptedAt),\n          lt(invitations.expiresAt, sql`now()`),\n        ),\n      );\n\n    const open = await tx\n      .select()\n      .from(invitations)\n      .where(\n        and(\n          eq(invitations.workspaceId, params.workspaceId),\n          eq(invitations.email, params.email),\n          isNull(invitations.acceptedAt),\n        ),\n      )\n      .limit(1);\n\n    if (open.length > 0) {\n      throw new OpenInvitationExistsError(params.email);\n    }\n\n    const rows = await tx\n      .insert(invitations)\n      .values({\n        workspaceId: params.workspaceId,\n        email: params.email,\n        hashedToken: params.hashedToken,\n        expiresAt: params.expiresAt,\n        invitedByUserId: params.invitedByUserId,\n        invitedByDisplay: params.invitedByDisplay ?? null,\n      })\n      .returning();\n\n    const row = rows[0];\n    if (!row) throw new Error('Insert returned no rows');\n    if (params.sendEmail) {\n      await writeOutboxEvent<WorkspacesEventMap>(tx, workspacesOutbox, {\n        type: WORKSPACES_INVITATION_SEND_REQUESTED,\n        payload: {\n          email: params.email,\n          ...params.sendEmail,\n        },\n      });\n    }\n    return {\n      invitation: toInvitation(row),\n      emailRequested: params.sendEmail ? ('requested' as const) : ('skipped' as const),\n    };\n  });\n\n  recordWorkspaceInvitationCreated(result.emailRequested);\n  return result.invitation;\n}\n\nexport async function findInvitationByToken(params: {\n  hashedToken: string;\n}): Promise<Invitation | undefined> {\n  const rows = await db()\n    .select()\n    .from(invitations)\n    .where(eq(invitations.hashedToken, params.hashedToken))\n    .limit(1);\n\n  const row = rows[0];\n  if (!row) return undefined;\n  return toInvitation(row);\n}\n\nexport async function findInvitationById(params: {id: string}): Promise<Invitation | undefined> {\n  const rows = await db().select().from(invitations).where(eq(invitations.id, params.id)).limit(1);\n\n  const row = rows[0];\n  if (!row) return undefined;\n  return toInvitation(row);\n}\n\nexport async function listOpenInvitationsByWorkspace(params: {\n  workspaceId: string;\n}): Promise<Invitation[]> {\n  const rows = await db()\n    .select()\n    .from(invitations)\n    .where(\n      and(\n        eq(invitations.workspaceId, params.workspaceId),\n        isNull(invitations.acceptedAt),\n        gt(invitations.expiresAt, sql`now()`),\n      ),\n    );\n\n  return rows.map(toInvitation);\n}\n\nexport async function revokeInvitation(params: {invitationId: string}): Promise<void> {\n  await db().delete(invitations).where(eq(invitations.id, params.invitationId));\n}\n\nexport interface AcceptInvitationParams {\n  invitationId: string;\n  acceptedByUserId: string;\n  acceptedByUserName?: string | null | undefined;\n}\n\nexport interface AcceptInvitationResult {\n  invitation: Invitation;\n  membership: Membership;\n  alreadyMember: boolean;\n}\n\nexport async function acceptInvitation(\n  params: AcceptInvitationParams,\n): Promise<AcceptInvitationResult | undefined> {\n  const result = await db().transaction(async (tx) => {\n    const inv = await tx\n      .select()\n      .from(invitations)\n      .where(\n        and(\n          eq(invitations.id, params.invitationId),\n          isNull(invitations.acceptedAt),\n          gt(invitations.expiresAt, sql`now()`),\n        ),\n      )\n      .limit(1);\n\n    const invRow = inv[0];\n    if (!invRow) return undefined;\n\n    const existing = await tx\n      .select()\n      .from(memberships)\n      .where(\n        and(\n          eq(memberships.userId, params.acceptedByUserId),\n          eq(memberships.workspaceId, invRow.workspaceId),\n        ),\n      )\n      .limit(1);\n\n    let membership: Membership;\n    let alreadyMember = false;\n    const existingRow = existing[0];\n\n    if (existingRow) {\n      alreadyMember = true;\n      membership = toMembership(existingRow);\n    } else {\n      const created = await tx\n        .insert(memberships)\n        .values(\n          membershipValues({\n            userId: params.acceptedByUserId,\n            userEmail: invRow.email,\n            userName: params.acceptedByUserName ?? null,\n            workspaceId: invRow.workspaceId,\n          }),\n        )\n        .returning();\n      const createdRow = created[0];\n      if (!createdRow) throw new Error('Insert returned no rows');\n      membership = toMembership(createdRow);\n    }\n\n    const updated = await tx\n      .update(invitations)\n      .set({\n        acceptedAt: sql`now()`,\n        acceptedByUserId: params.acceptedByUserId,\n        updatedAt: sql`now()`,\n      })\n      .where(eq(invitations.id, params.invitationId))\n      .returning();\n\n    const updatedRow = updated[0];\n    if (!updatedRow) throw new Error('Update returned no rows');\n\n    return {invitation: toInvitation(updatedRow), membership, alreadyMember};\n  });\n\n  if (result && !result.alreadyMember) recordWorkspaceMembershipChanged('added');\n  if (result) {\n    recordWorkspaceInvitationAccepted(result.alreadyMember ? 'already_member' : 'added');\n  }\n  return result;\n}\n"],"names":["WORKSPACES_INVITATION_SEND_REQUESTED","writeOutboxEvent","and","eq","gt","isNull","lt","sql","OpenInvitationExistsError","recordWorkspaceInvitationAccepted","recordWorkspaceInvitationCreated","recordWorkspaceMembershipChanged","db","membershipValues","invitations","toInvitation","memberships","toMembership","workspacesOutbox","createInvitation","params","result","transaction","tx","delete","where","workspaceId","email","acceptedAt","expiresAt","open","select","from","limit","length","rows","insert","values","hashedToken","invitedByUserId","invitedByDisplay","returning","row","Error","sendEmail","type","payload","invitation","emailRequested","findInvitationByToken","undefined","findInvitationById","id","listOpenInvitationsByWorkspace","map","revokeInvitation","invitationId","acceptInvitation","inv","invRow","existing","userId","acceptedByUserId","membership","alreadyMember","existingRow","created","userEmail","userName","acceptedByUserName","createdRow","updated","update","set","updatedAt","updatedRow"],"mappings":"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"}

package/dist/db/memberships.d.ts

@@ -0,0 +1,44 @@
+import type { Membership } from '#core/entities/membership.js';
+export interface CreateMembershipParams {
+    userId: string;
+    userEmail?: string | undefined;
+    userName?: string | null | undefined;
+    workspaceId: string;
+}
+export interface EnsureMembershipParams {
+    userId: string;
+    userEmail: string;
+    userName: string | null;
+    workspaceId: string;
+}
+export declare function membershipValues(params: CreateMembershipParams): {
+    userId: string;
+    userEmail: string;
+    userName: string | null;
+    workspaceId: string;
+};
+export declare function createMembership(params: CreateMembershipParams): Promise<Membership>;
+export declare function ensureMembership(params: EnsureMembershipParams): Promise<Membership>;
+export interface MembershipWithWorkspace extends Membership {
+    workspaceName: string;
+}
+export declare function listMembershipsByUser(params: {
+    userId: string;
+}): Promise<MembershipWithWorkspace[]>;
+export interface MembershipWithUser extends Membership {
+    userEmail: string;
+    userName: string | null;
+}
+export declare function listMembershipsByWorkspace(params: {
+    workspaceId: string;
+}): Promise<MembershipWithUser[]>;
+export declare function findMembership(params: {
+    userId: string;
+    workspaceId: string;
+}): Promise<Membership | undefined>;
+export interface RemoveMembershipParams {
+    userId: string;
+    workspaceId: string;
+}
+export declare function removeMembership(params: RemoveMembershipParams): Promise<void>;
+//# sourceMappingURL=memberships.d.ts.map

package/dist/db/memberships.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memberships.d.ts","sourceRoot":"","sources":["../../src/db/memberships.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,8BAA8B,CAAC;AAO7D,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACrC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,sBAAsB;;;;;EAO9D;AAED,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,UAAU,CAAC,CAO1F;AAED,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,UAAU,CAAC,CAgB1F;AAED,MAAM,WAAW,uBAAwB,SAAQ,UAAU;IACzD,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,wBAAsB,qBAAqB,CAAC,MAAM,EAAE;IAClD,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAYrC;AAED,MAAM,WAAW,kBAAmB,SAAQ,UAAU;IACpD,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED,wBAAsB,0BAA0B,CAAC,MAAM,EAAE;IACvD,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAOhC;AAED,wBAAsB,cAAc,CAAC,MAAM,EAAE;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAYlC;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAsBpF"}

package/dist/db/memberships.js

@@ -0,0 +1,75 @@
+import { and, eq, sql } from 'drizzle-orm';
+import { LastMemberError } from '#core/errors.js';
+import { recordWorkspaceMembershipChanged } from '#metrics/instance.js';
+import { db } from './db.js';
+import { memberships, toMembership } from './schema/memberships.js';
+import { workspaces } from './schema/workspaces.js';
+export function membershipValues(params) {
+    return {
+        userId: params.userId,
+        userEmail: params.userEmail ?? `user-${params.userId}@example.local`,
+        userName: params.userName ?? null,
+        workspaceId: params.workspaceId
+    };
+}
+export async function createMembership(params) {
+    const rows = await db().insert(memberships).values(membershipValues(params)).returning();
+    const row = rows[0];
+    if (!row) throw new Error('Insert returned no rows');
+    recordWorkspaceMembershipChanged('added');
+    return toMembership(row);
+}
+export async function ensureMembership(params) {
+    const rows = await db().insert(memberships).values(membershipValues(params)).onConflictDoNothing({
+        target: [
+            memberships.userId,
+            memberships.workspaceId
+        ]
+    }).returning();
+    const row = rows[0];
+    if (row) {
+        recordWorkspaceMembershipChanged('added');
+        return toMembership(row);
+    }
+    const existing = await findMembership(params);
+    if (existing) return existing;
+    throw new Error('Membership conflict returned no membership');
+}
+export async function listMembershipsByUser(params) {
+    const rows = await db().select({
+        membership: memberships,
+        workspaceName: workspaces.name
+    }).from(memberships).innerJoin(workspaces, eq(workspaces.id, memberships.workspaceId)).where(eq(memberships.userId, params.userId)).orderBy(workspaces.name);
+    return rows.map((row)=>({
+            ...toMembership(row.membership),
+            workspaceName: row.workspaceName
+        }));
+}
+export async function listMembershipsByWorkspace(params) {
+    const rows = await db().select().from(memberships).where(eq(memberships.workspaceId, params.workspaceId));
+    return rows.map(toMembership);
+}
+export async function findMembership(params) {
+    const rows = await db().select().from(memberships).where(and(eq(memberships.userId, params.userId), eq(memberships.workspaceId, params.workspaceId))).limit(1);
+    const row = rows[0];
+    if (!row) return undefined;
+    return toMembership(row);
+}
+export async function removeMembership(params) {
+    const removed = await db().transaction(async (tx)=>{
+        const countResult = await tx.select({
+            count: sql`count(*)::int`
+        }).from(memberships).where(eq(memberships.workspaceId, params.workspaceId));
+        const total = countResult[0]?.count ?? 0;
+        if (total <= 1) {
+            throw new LastMemberError(params.workspaceId);
+        }
+        const deleted = await tx.delete(memberships).where(and(eq(memberships.userId, params.userId), eq(memberships.workspaceId, params.workspaceId))).returning({
+            id: memberships.id
+        });
+        return deleted.length > 0;
+    });
+    if (removed) recordWorkspaceMembershipChanged('removed');
+}
+
+//# sourceMappingURL=memberships.js.map

package/dist/db/memberships.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/memberships.ts"],"sourcesContent":["import {and, eq, sql} from 'drizzle-orm';\nimport type {Membership} from '#core/entities/membership.js';\nimport {LastMemberError} from '#core/errors.js';\nimport {recordWorkspaceMembershipChanged} from '#metrics/instance.js';\nimport {db} from './db.js';\nimport {memberships, toMembership} from './schema/memberships.js';\nimport {workspaces} from './schema/workspaces.js';\n\nexport interface CreateMembershipParams {\n  userId: string;\n  userEmail?: string | undefined;\n  userName?: string | null | undefined;\n  workspaceId: string;\n}\n\nexport interface EnsureMembershipParams {\n  userId: string;\n  userEmail: string;\n  userName: string | null;\n  workspaceId: string;\n}\n\nexport function membershipValues(params: CreateMembershipParams) {\n  return {\n    userId: params.userId,\n    userEmail: params.userEmail ?? `user-${params.userId}@example.local`,\n    userName: params.userName ?? null,\n    workspaceId: params.workspaceId,\n  };\n}\n\nexport async function createMembership(params: CreateMembershipParams): Promise<Membership> {\n  const rows = await db().insert(memberships).values(membershipValues(params)).returning();\n\n  const row = rows[0];\n  if (!row) throw new Error('Insert returned no rows');\n  recordWorkspaceMembershipChanged('added');\n  return toMembership(row);\n}\n\nexport async function ensureMembership(params: EnsureMembershipParams): Promise<Membership> {\n  const rows = await db()\n    .insert(memberships)\n    .values(membershipValues(params))\n    .onConflictDoNothing({target: [memberships.userId, memberships.workspaceId]})\n    .returning();\n\n  const row = rows[0];\n  if (row) {\n    recordWorkspaceMembershipChanged('added');\n    return toMembership(row);\n  }\n\n  const existing = await findMembership(params);\n  if (existing) return existing;\n  throw new Error('Membership conflict returned no membership');\n}\n\nexport interface MembershipWithWorkspace extends Membership {\n  workspaceName: string;\n}\n\nexport async function listMembershipsByUser(params: {\n  userId: string;\n}): Promise<MembershipWithWorkspace[]> {\n  const rows = await db()\n    .select({\n      membership: memberships,\n      workspaceName: workspaces.name,\n    })\n    .from(memberships)\n    .innerJoin(workspaces, eq(workspaces.id, memberships.workspaceId))\n    .where(eq(memberships.userId, params.userId))\n    .orderBy(workspaces.name);\n\n  return rows.map((row) => ({...toMembership(row.membership), workspaceName: row.workspaceName}));\n}\n\nexport interface MembershipWithUser extends Membership {\n  userEmail: string;\n  userName: string | null;\n}\n\nexport async function listMembershipsByWorkspace(params: {\n  workspaceId: string;\n}): Promise<MembershipWithUser[]> {\n  const rows = await db()\n    .select()\n    .from(memberships)\n    .where(eq(memberships.workspaceId, params.workspaceId));\n\n  return rows.map(toMembership);\n}\n\nexport async function findMembership(params: {\n  userId: string;\n  workspaceId: string;\n}): Promise<Membership | undefined> {\n  const rows = await db()\n    .select()\n    .from(memberships)\n    .where(\n      and(eq(memberships.userId, params.userId), eq(memberships.workspaceId, params.workspaceId)),\n    )\n    .limit(1);\n\n  const row = rows[0];\n  if (!row) return undefined;\n  return toMembership(row);\n}\n\nexport interface RemoveMembershipParams {\n  userId: string;\n  workspaceId: string;\n}\n\nexport async function removeMembership(params: RemoveMembershipParams): Promise<void> {\n  const removed = await db().transaction(async (tx) => {\n    const countResult = await tx\n      .select({count: sql<number>`count(*)::int`})\n      .from(memberships)\n      .where(eq(memberships.workspaceId, params.workspaceId));\n    const total = countResult[0]?.count ?? 0;\n    if (total <= 1) {\n      throw new LastMemberError(params.workspaceId);\n    }\n\n    const deleted = await tx\n      .delete(memberships)\n      .where(\n        and(eq(memberships.userId, params.userId), eq(memberships.workspaceId, params.workspaceId)),\n      )\n      .returning({id: memberships.id});\n\n    return deleted.length > 0;\n  });\n\n  if (removed) recordWorkspaceMembershipChanged('removed');\n}\n"],"names":["and","eq","sql","LastMemberError","recordWorkspaceMembershipChanged","db","memberships","toMembership","workspaces","membershipValues","params","userId","userEmail","userName","workspaceId","createMembership","rows","insert","values","returning","row","Error","ensureMembership","onConflictDoNothing","target","existing","findMembership","listMembershipsByUser","select","membership","workspaceName","name","from","innerJoin","id","where","orderBy","map","listMembershipsByWorkspace","limit","undefined","removeMembership","removed","transaction","tx","countResult","count","total","deleted","delete","length"],"mappings":"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"}

package/dist/db/schema/common.d.ts

@@ -0,0 +1,2 @@
+export declare const pgTable: import("drizzle-orm/pg-core").PgTableFn<undefined>;
+//# sourceMappingURL=common.d.ts.map

package/dist/db/schema/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/db/schema/common.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO,oDAEnB,CAAC"}

package/dist/db/schema/common.js

@@ -0,0 +1,4 @@
+import { pgTableCreator } from 'drizzle-orm/pg-core';
+export const pgTable = pgTableCreator((name)=>name === 'workspaces' ? name : `workspaces_${name}`);
+
+//# sourceMappingURL=common.js.map

package/dist/db/schema/common.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/common.ts"],"sourcesContent":["import {pgTableCreator} from 'drizzle-orm/pg-core';\n\nexport const pgTable = pgTableCreator((name) =>\n  name === 'workspaces' ? name : `workspaces_${name}`,\n);\n"],"names":["pgTableCreator","pgTable","name"],"mappings":"AAAA,SAAQA,cAAc,QAAO,sBAAsB;AAEnD,OAAO,MAAMC,UAAUD,eAAe,CAACE,OACrCA,SAAS,eAAeA,OAAO,CAAC,WAAW,EAAEA,MAAM,EACnD"}

package/dist/db/schema/invitations.d.ts

@@ -0,0 +1,199 @@
+import type { Invitation } from '#core/entities/invitation.js';
+export declare const invitations: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "invitations";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "invitations";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        workspaceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workspace_id";
+            tableName: "invitations";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        email: import("drizzle-orm/pg-core").PgColumn<{
+            name: "email";
+            tableName: "invitations";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        hashedToken: import("drizzle-orm/pg-core").PgColumn<{
+            name: "hashed_token";
+            tableName: "invitations";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        expiresAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "expires_at";
+            tableName: "invitations";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        acceptedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "accepted_at";
+            tableName: "invitations";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        acceptedByUserId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "accepted_by_user_id";
+            tableName: "invitations";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        invitedByUserId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "invited_by_user_id";
+            tableName: "invitations";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        invitedByDisplay: import("drizzle-orm/pg-core").PgColumn<{
+            name: "invited_by_display";
+            tableName: "invitations";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "invitations";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "invitations";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type InvitationDb = typeof invitations.$inferSelect;
+export type InvitationCreateDb = typeof invitations.$inferInsert;
+export declare function toInvitation(row: InvitationDb): Invitation;
+//# sourceMappingURL=invitations.d.ts.map

package/dist/db/schema/invitations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invitations.d.ts","sourceRoot":"","sources":["../../../src/db/schema/invitations.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,8BAA8B,CAAC;AAI7D,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBvB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,OAAO,WAAW,CAAC,YAAY,CAAC;AAC3D,MAAM,MAAM,kBAAkB,GAAG,OAAO,WAAW,CAAC,YAAY,CAAC;AAEjE,wBAAgB,YAAY,CAAC,GAAG,EAAE,YAAY,GAAG,UAAU,CAc1D"}