@tangle-network/agent-app 0.45.53 → 0.45.55

package/dist/teams/drizzle/access.d.ts

@@ -0,0 +1,82 @@
+/**
+ * RBAC access builders over the teams tables. `createWorkspaceAccess` and
+ * `createOrganizationAccess` close over the product's `db`, the tables from
+ * `createTeamTables`, and the product's `workspace` table, returning the exact
+ * `getWorkspaceAccess` / `requireWorkspaceAccess` / `listUserWorkspaces` /
+ * `getOrganizationAccess` / `requireOrganizationAccess` functions a consumer
+ * already calls — so adoption is a one-line import swap, every call site stays
+ * identical.
+ *
+ * Defense in depth: org owners/admins are workspace owners across the org;
+ * everyone else gets their explicit per-workspace role. Effective role is the
+ * fold in `resolveWorkspaceRole` (pure, from `../roles`). Every query pins
+ * `userId`, so a leaked id can never read across the tenancy boundary — it
+ * surfaces as "not found".
+ *
+ * Driver-agnostic: builders are awaited, never `.run()`/`.all()`, so
+ * better-sqlite3, D1, and libsql handles all behave identically.
+ */
+import type { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
+import { type OrganizationRole, type WorkspaceRole } from '../roles';
+import type { TeamParentTable } from './schema';
+import type { OrganizationMemberRow, OrganizationRow, TeamTables } from './schema';
+/** Any SQLite drizzle database — `any` erases driver-specific generics so
+ *  better-sqlite3, D1, and libsql handles all fit. */
+export type TeamDatabase = BaseSQLiteDatabase<'sync' | 'async', any, any>;
+/**
+ * The product's workspace table, narrowed to the columns the access joins read.
+ * Adopters pass their real drizzle workspace table — it carries these columns
+ * (gtm's does); the type only asserts the minimum the joins touch.
+ */
+export interface WorkspaceAccessTable {
+    id: any;
+    organizationId: any;
+    name: any;
+    updatedAt: any;
+}
+/** Define options required to create access with database, tables, and workspace table references */
+export interface CreateAccessOptions {
+    db: TeamDatabase;
+    tables: TeamTables;
+    /** The product's workspace table (the FK target passed to createTeamTables). */
+    workspaceTable: TeamParentTable & WorkspaceAccessTable;
+}
+/** Define access details including workspace data, organization info, member info, and role within workspace */
+export interface WorkspaceAccess {
+    workspace: Record<string, unknown>;
+    organization: OrganizationRow;
+    organizationMember: OrganizationMemberRow;
+    role: WorkspaceRole;
+}
+/** Describe a user's workspace details including organization and role information */
+export interface UserWorkspaceSummary extends Record<string, unknown> {
+    organizationId: string;
+    organizationName: string;
+    role: WorkspaceRole;
+}
+/** Define methods to retrieve and enforce user access permissions within workspaces */
+export interface WorkspaceAccessApi {
+    getWorkspaceAccess(workspaceId: string, userId: string, minRole?: WorkspaceRole): Promise<WorkspaceAccess | null>;
+    requireWorkspaceAccess(workspaceId: string, userId: string, minRole?: WorkspaceRole): Promise<WorkspaceAccess>;
+    listUserWorkspaces(userId: string): Promise<UserWorkspaceSummary[]>;
+}
+/** Create workspace access API to manage user roles and permissions within a workspace */
+export declare function createWorkspaceAccess(opts: CreateAccessOptions): WorkspaceAccessApi;
+/** Define access details linking an organization, its member, and the member's role */
+export interface OrganizationAccess {
+    organization: OrganizationRow;
+    member: OrganizationMemberRow;
+    role: OrganizationRole;
+}
+/** Define methods to retrieve and enforce user access levels within an organization */
+export interface OrganizationAccessApi {
+    getOrganizationAccess(organizationId: string, userId: string, minRole?: OrganizationRole): Promise<OrganizationAccess | null>;
+    requireOrganizationAccess(organizationId: string, userId: string, minRole?: OrganizationRole): Promise<OrganizationAccess>;
+}
+/** Define options required to create access for an organization including database and tables */
+export interface CreateOrganizationAccessOptions {
+    db: TeamDatabase;
+    tables: TeamTables;
+}
+/** Resolve organization access API with specified database and table options */
+export declare function createOrganizationAccess(opts: CreateOrganizationAccessOptions): OrganizationAccessApi;

package/dist/{invitations-schema-_fI7HkJP.d.ts → teams/drizzle/invitations-schema.d.ts}

@@ -1,8 +1,22 @@
-import * as drizzle_orm_sqlite_core from 'drizzle-orm/sqlite-core';
-import { g as TeamParentTable } from './access-490O6aOU.js';
-
+/**
+ * Drizzle schema factory for the dedicated workspace-invitation table. Separate
+ * from `createTeamTables` on purpose: an app opts into the rich email-invitation
+ * lifecycle (status / expiry / resend / revoke / preview) by calling this, and an
+ * app that doesn't want it never grows the table — `createTeamTables`'s output and
+ * migrations stay untouched.
+ *
+ * The product owns the user and workspace tables; `organizations` comes from
+ * `createTeamTables`. Pass all three so the invitation's FKs wire into the same
+ * drizzle schema with real cascade semantics. Call this AFTER `createTeamTables`
+ * (so `organizations` exists) — the lazy `.references(() => ...)` closures make
+ * the ordering within one module safe.
+ *
+ * Columns / enums / indexes mirror creative-agent's validated hand-rolled table,
+ * so an app already running that table adopts this factory with no row rewrite.
+ */
+import type { TeamParentTable } from './schema';
 /** Define options for creating a workspace invitation table with user, workspace, and organization references */
-interface CreateWorkspaceInvitationTableOptions {
+export interface CreateWorkspaceInvitationTableOptions {
     /** The product's user table — `invitedByUserId` references `userTable.id`. */
     userTable: TeamParentTable;
     /** The product's workspace table — `workspaceId` references `workspaceTable.id`. */
@@ -11,12 +25,12 @@ interface CreateWorkspaceInvitationTableOptions {
     organizationTable: TeamParentTable;
 }
 /** Build a workspace invitation table with defined columns and foreign key constraints */
-declare function createWorkspaceInvitationTable(opts: CreateWorkspaceInvitationTableOptions): {
-    workspaceInvitations: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
+export declare function createWorkspaceInvitationTable(opts: CreateWorkspaceInvitationTableOptions): {
+    workspaceInvitations: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
         name: "workspace_invitation";
         schema: undefined;
         columns: {
-            id: drizzle_orm_sqlite_core.SQLiteColumn<{
+            id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
                 name: "id";
                 tableName: "workspace_invitation";
                 dataType: "string";
@@ -35,7 +49,7 @@ declare function createWorkspaceInvitationTable(opts: CreateWorkspaceInvitationT
             }, {}, {
                 length: number | undefined;
             }>;
-            workspaceId: drizzle_orm_sqlite_core.SQLiteColumn<{
+            workspaceId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
                 name: "workspace_id";
                 tableName: "workspace_invitation";
                 dataType: "string";
@@ -54,7 +68,7 @@ declare function createWorkspaceInvitationTable(opts: CreateWorkspaceInvitationT
             }, {}, {
                 length: number | undefined;
             }>;
-            organizationId: drizzle_orm_sqlite_core.SQLiteColumn<{
+            organizationId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
                 name: "organization_id";
                 tableName: "workspace_invitation";
                 dataType: "string";
@@ -73,7 +87,7 @@ declare function createWorkspaceInvitationTable(opts: CreateWorkspaceInvitationT
             }, {}, {
                 length: number | undefined;
             }>;
-            email: drizzle_orm_sqlite_core.SQLiteColumn<{
+            email: import("drizzle-orm/sqlite-core").SQLiteColumn<{
                 name: "email";
                 tableName: "workspace_invitation";
                 dataType: "string";
@@ -92,7 +106,7 @@ declare function createWorkspaceInvitationTable(opts: CreateWorkspaceInvitationT
             }, {}, {
                 length: number | undefined;
             }>;
-            invitedByUserId: drizzle_orm_sqlite_core.SQLiteColumn<{
+            invitedByUserId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
                 name: "invited_by_user_id";
                 tableName: "workspace_invitation";
                 dataType: "string";
@@ -111,12 +125,12 @@ declare function createWorkspaceInvitationTable(opts: CreateWorkspaceInvitationT
             }, {}, {
                 length: number | undefined;
             }>;
-            permissions: drizzle_orm_sqlite_core.SQLiteColumn<{
+            permissions: import("drizzle-orm/sqlite-core").SQLiteColumn<{
                 name: "permissions";
                 tableName: "workspace_invitation";
                 dataType: "string";
                 columnType: "SQLiteText";
-                data: "viewer" | "editor" | "admin";
+                data: "admin" | "viewer" | "editor";
                 driverParam: string;
                 notNull: true;
                 hasDefault: true;
@@ -130,7 +144,7 @@ declare function createWorkspaceInvitationTable(opts: CreateWorkspaceInvitationT
             }, {}, {
                 length: number | undefined;
             }>;
-            token: drizzle_orm_sqlite_core.SQLiteColumn<{
+            token: import("drizzle-orm/sqlite-core").SQLiteColumn<{
                 name: "token";
                 tableName: "workspace_invitation";
                 dataType: "string";
@@ -149,12 +163,12 @@ declare function createWorkspaceInvitationTable(opts: CreateWorkspaceInvitationT
             }, {}, {
                 length: number | undefined;
             }>;
-            status: drizzle_orm_sqlite_core.SQLiteColumn<{
+            status: import("drizzle-orm/sqlite-core").SQLiteColumn<{
                 name: "status";
                 tableName: "workspace_invitation";
                 dataType: "string";
                 columnType: "SQLiteText";
-                data: "expired" | "pending" | "accepted" | "revoked";
+                data: "expired" | "revoked" | "pending" | "accepted";
                 driverParam: string;
                 notNull: true;
                 hasDefault: true;
@@ -168,12 +182,12 @@ declare function createWorkspaceInvitationTable(opts: CreateWorkspaceInvitationT
             }, {}, {
                 length: number | undefined;
             }>;
-            emailStatus: drizzle_orm_sqlite_core.SQLiteColumn<{
+            emailStatus: import("drizzle-orm/sqlite-core").SQLiteColumn<{
                 name: "email_status";
                 tableName: "workspace_invitation";
                 dataType: "string";
                 columnType: "SQLiteText";
-                data: "not_sent" | "sent" | "failed";
+                data: "failed" | "not_sent" | "sent";
                 driverParam: string;
                 notNull: true;
                 hasDefault: true;
@@ -187,7 +201,7 @@ declare function createWorkspaceInvitationTable(opts: CreateWorkspaceInvitationT
             }, {}, {
                 length: number | undefined;
             }>;
-            expiresAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            expiresAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
                 name: "expires_at";
                 tableName: "workspace_invitation";
                 dataType: "date";
@@ -204,7 +218,7 @@ declare function createWorkspaceInvitationTable(opts: CreateWorkspaceInvitationT
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
-            createdAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
                 name: "created_at";
                 tableName: "workspace_invitation";
                 dataType: "date";
@@ -221,7 +235,7 @@ declare function createWorkspaceInvitationTable(opts: CreateWorkspaceInvitationT
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
-            acceptedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            acceptedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
                 name: "accepted_at";
                 tableName: "workspace_invitation";
                 dataType: "date";
@@ -238,7 +252,7 @@ declare function createWorkspaceInvitationTable(opts: CreateWorkspaceInvitationT
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
-            revokedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            revokedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
                 name: "revoked_at";
                 tableName: "workspace_invitation";
                 dataType: "date";
@@ -255,7 +269,7 @@ declare function createWorkspaceInvitationTable(opts: CreateWorkspaceInvitationT
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
-            lastSentAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            lastSentAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
                 name: "last_sent_at";
                 tableName: "workspace_invitation";
                 dataType: "date";
@@ -277,8 +291,6 @@ declare function createWorkspaceInvitationTable(opts: CreateWorkspaceInvitationT
     }>;
 };
 /** Resolve the structure of workspace invitation tables from the creation function */
-type WorkspaceInvitationTables = ReturnType<typeof createWorkspaceInvitationTable>;
+export type WorkspaceInvitationTables = ReturnType<typeof createWorkspaceInvitationTable>;
 /** Resolve the structure of a workspace invitation row from the workspaceInvitations table */
-type WorkspaceInvitationRow = WorkspaceInvitationTables['workspaceInvitations']['$inferSelect'];
-
-export { type CreateWorkspaceInvitationTableOptions as C, type WorkspaceInvitationRow as W, type WorkspaceInvitationTables as a, createWorkspaceInvitationTable as c };
+export type WorkspaceInvitationRow = WorkspaceInvitationTables['workspaceInvitations']['$inferSelect'];

package/dist/teams/drizzle/personal-organization.d.ts

@@ -0,0 +1,41 @@
+/**
+ * `ensurePersonalOrganization` — the substrate that makes solo-user adoption
+ * work. Every user gets exactly one auto-created `kind: 'personal'` org with
+ * the user as `owner` member. That org is the tenant that owns their
+ * workspaces, so role resolution (`getWorkspaceAccess`) has an org row to read
+ * even before any team/invite exists.
+ *
+ * Idempotent by construction: the org `slug` is derived from the user id
+ * (`personal-<id>`) and upserted; the membership upserts on the
+ * (organizationId, userId) unique index. Concurrent calls converge — no
+ * duplicate personal orgs, no duplicate owner rows.
+ *
+ * ADOPTION CONTRACT: call this once per user at first authenticated entry
+ * (e.g. right after sign-in / session bootstrap) BEFORE the first
+ * `getWorkspaceAccess`. Role resolution requires the org membership to exist;
+ * an adopter that skips this will see `null` access for a brand-new user with
+ * no org row. There is no implicit creation inside the access builders — that
+ * keeps reads side-effect-free; provisioning is this explicit call.
+ */
+import type { OrganizationRole } from '../roles';
+import type { TeamDatabase } from './access';
+import type { OrganizationMemberRow, OrganizationRow, TeamTables } from './schema';
+/** Define the structure for a user within a personal organization context */
+export interface EnsurePersonalOrganizationUser {
+    id: string;
+    name?: string | null;
+    email?: string | null;
+}
+/** Describe a personal organization result including organization, member, and role details */
+export interface PersonalOrganizationResult {
+    organization: OrganizationRow;
+    member: OrganizationMemberRow;
+    role: OrganizationRole;
+}
+/** Define options required to create a personal organization including database and tables references */
+export interface CreatePersonalOrganizationOptions {
+    db: TeamDatabase;
+    tables: TeamTables;
+}
+/** Ensure a user has a personal organization by creating or retrieving it as needed */
+export declare function createEnsurePersonalOrganization(opts: CreatePersonalOrganizationOptions): (user: EnsurePersonalOrganizationUser) => Promise<PersonalOrganizationResult>;