@plandesk/api 1.0.0-beta.2 → 1.0.0-beta.3

package/dist/auth.js

@@ -187,6 +187,7 @@ async function resolveBetterAuthApiKeyContext(auth, bearer) {
  */
 const PUBLIC_AUTH_PATHS = new Set([
     '/api/v1/auth/methods',
+    '/api/v1/health',
     '/api/auth/*',
 ]);
 /** Invitation accept: invitee may have a session but zero org memberships yet. */

package/dist/index.d.ts

@@ -12,6 +12,7 @@ export { requirePermission, hasPermission, hasAnyWritePermission, orgRoleToPermi
 export { healthRouter } from './routes/health.js';
 export { mountStatic } from './static.js';
 export { createS3Adapter, type S3AdapterConfig } from './storage/s3.js';
+export { createR2Adapter, type R2BucketLike } from './storage/r2.js';
 export type { StorageAdapter } from './storage/adapter.js';
 export { createServices, type Services, type ServicesDeps } from './services/index.js';
 export { assertProjectInOrg, ProjectNotInOrgError } from './services/scope.js';

package/dist/index.js

@@ -12,6 +12,7 @@ export { requirePermission, hasPermission, hasAnyWritePermission, orgRoleToPermi
 export { healthRouter } from './routes/health.js';
 export { mountStatic } from './static.js';
 export { createS3Adapter } from './storage/s3.js';
+export { createR2Adapter } from './storage/r2.js';
 export { createServices } from './services/index.js';
 export { assertProjectInOrg, ProjectNotInOrgError } from './services/scope.js';
 export { GoalCompletionBlockedError, GoalVerificationRequiredError, InvalidGoalTransitionError, InvalidVerificationSurfaceError, } from './services/goals.js';

package/dist/organizations.d.ts

@@ -20,6 +20,16 @@ export declare function getOrganizationById(auth: BetterAuthInstance, organizati
  */
 export declare function resolveDefaultOrganization(auth: BetterAuthInstance): Promise<OrganizationSummary | undefined>;
 export declare function listOrganizationsForUser(auth: BetterAuthInstance, userId: string): Promise<UserOrganizationSummary[]>;
+export type OrganizationMemberSummary = {
+    id: string;
+    userId: string;
+    email: string;
+    name: string;
+    role: string;
+    createdAt: string;
+};
+/** List better-auth members of an organization (email/name joined from user). */
+export declare function listOrganizationMembers(auth: BetterAuthInstance, organizationId: string): Promise<OrganizationMemberSummary[]>;
 /**
  * Display-friendly org for /auth/session and similar.
  * Falls back to DEFAULT_ORG_ID → "Personal" when better-auth is not configured

package/dist/organizations.js

@@ -43,6 +43,31 @@ export async function listOrganizationsForUser(auth, userId) {
         return { id: organization.id, name: organization.name, role: member.role };
     }));
 }
+/** List better-auth members of an organization (email/name joined from user). */
+export async function listOrganizationMembers(auth, organizationId) {
+    const adapter = (await auth.$context).adapter;
+    const members = await adapter.findMany({
+        model: 'member',
+        where: [{ field: 'organizationId', value: organizationId }],
+        sortBy: { field: 'createdAt', direction: 'asc' },
+    });
+    return Promise.all(members.map(async (member) => {
+        const user = await adapter.findOne({
+            model: 'user',
+            where: [{ field: 'id', value: member.userId }],
+        });
+        return {
+            id: member.id,
+            userId: member.userId,
+            email: user?.email ?? '',
+            name: user?.name ?? '',
+            role: member.role,
+            createdAt: member.createdAt instanceof Date
+                ? member.createdAt.toISOString()
+                : String(member.createdAt),
+        };
+    }));
+}
 /**
  * Display-friendly org for /auth/session and similar.
  * Falls back to DEFAULT_ORG_ID → "Personal" when better-auth is not configured

package/dist/routes/orgs.js

@@ -3,7 +3,7 @@ import { getProjectInOrg, importProject, InvalidExportVersionError, PLANDESK_EXP
 import { createScopedAgentKey } from '../agent-keys.js';
 import { getAuthContext, getOrgAuthContext } from '../auth-context.js';
 import { acceptOrganizationInvitation, createOrganizationInvitation, isAuthApiError, isInvitationRole, } from '../invitations.js';
-import { getOrganizationById } from '../organizations.js';
+import { getOrganizationById, listOrganizationMembers } from '../organizations.js';
 import { requirePermission } from '../permissions.js';
 function isPermissionSet(value) {
     if (value === null || typeof value !== 'object' || Array.isArray(value)) {
@@ -107,6 +107,20 @@ export function createOrgsRouter(db, options = {}) {
         const minted = await createScopedAgentKey(mintInput);
         return c.json({ token: minted.key, project_id: projectId }, 200);
     });
+    /**
+     * List better-auth org members (role + email). Any org member may read.
+     */
+    router.get('/orgs/:id/members', async (c) => {
+        const orgId = c.req.param('id');
+        if (!(await requireKnownOrg(orgId))) {
+            return c.json({ error: 'not_found' }, 404);
+        }
+        if (betterAuth === undefined) {
+            return c.json({ error: 'unavailable' }, 503);
+        }
+        const members = await listOrganizationMembers(betterAuth, orgId);
+        return c.json({ members }, 200);
+    });
     /**
      * BA3c: invite by email (link-only, no mailer). Session owner only
      * (member:create). Returns claimUrl for the inviter to deliver by hand.

package/dist/storage/index.d.ts

@@ -1,11 +1,15 @@
 import type { Db } from '@plandesk/db';
 import type { StorageAdapter } from './adapter.js';
+import { type R2BucketLike } from './r2.js';
 export * from './adapter.js';
 export { createLocalBlobAdapter } from './local.js';
+export { createR2Adapter, type R2BucketLike } from './r2.js';
 export { createS3Adapter, readS3ConfigFromEnv, type S3AdapterConfig } from './s3.js';
 export type CreateStorageAdapterDeps = {
     db: Db;
     env?: NodeJS.ProcessEnv;
+    /** When set (Workers), prefer the native R2 binding over S3/local. */
+    r2?: R2BucketLike;
 };
 export declare function createStorageAdapter(deps: CreateStorageAdapterDeps): StorageAdapter;
 //# sourceMappingURL=index.d.ts.map

package/dist/storage/index.js

@@ -1,9 +1,14 @@
 import { createLocalBlobAdapter } from './local.js';
+import { createR2Adapter } from './r2.js';
 import { createS3Adapter, readS3ConfigFromEnv } from './s3.js';
 export * from './adapter.js';
 export { createLocalBlobAdapter } from './local.js';
+export { createR2Adapter } from './r2.js';
 export { createS3Adapter, readS3ConfigFromEnv } from './s3.js';
 export function createStorageAdapter(deps) {
+    if (deps.r2 !== undefined) {
+        return createR2Adapter({ db: deps.db, bucket: deps.r2 });
+    }
     const env = deps.env ?? process.env;
     const kind = env.PLANDESK_STORAGE ?? 'local';
     if (kind === 's3') {

package/dist/storage/r2.d.ts

@@ -0,0 +1,40 @@
+import { type Db } from '@plandesk/db';
+import { type StorageAdapter } from './adapter.js';
+/**
+ * Minimal R2Bucket surface used by the adapter (matches Workers binding API).
+ * Tests supply an in-memory fake; production passes env.FILES.
+ */
+export type R2BucketLike = {
+    put(key: string, value: ArrayBuffer | ArrayBufferView | string | null | Blob, options?: {
+        httpMetadata?: {
+            contentType?: string;
+        };
+        customMetadata?: Record<string, string>;
+    }): Promise<unknown>;
+    get(key: string): Promise<{
+        arrayBuffer(): Promise<ArrayBuffer>;
+        httpMetadata?: {
+            contentType?: string;
+        };
+        customMetadata?: Record<string, string>;
+    } | null>;
+    head(key: string): Promise<{
+        httpMetadata?: {
+            contentType?: string;
+        };
+        customMetadata?: Record<string, string>;
+    } | null>;
+};
+export type R2AdapterDeps = {
+    db: Db;
+    bucket: R2BucketLike;
+};
+/**
+ * Content-addressed R2 storage via the native Workers binding (not S3 creds).
+ * Bytes live in the bucket under `{projectId}/{sha256}`; the `files` row records
+ * metadata + org linkage. `resolve` is org-scoped through `getFileInOrg` — the
+ * bare content id is never a lookup key, so one tenant cannot read another's
+ * bytes by knowing the hash (mirrors the local/s3 adapters).
+ */
+export declare function createR2Adapter(deps: R2AdapterDeps): StorageAdapter;
+//# sourceMappingURL=r2.d.ts.map

package/dist/storage/r2.js

@@ -0,0 +1,65 @@
+import { createHash } from 'node:crypto';
+import { createFile, getFileInOrg } from '@plandesk/db';
+import { tryGetAuthContext } from '../auth-context.js';
+import { fileUrl } from './adapter.js';
+// Per-project object key, mirroring the (project_id, id) primary key of the
+// `files` table: identical bytes in different projects never collide.
+function objectKey(projectId, id) {
+    return `${projectId}/${id}`;
+}
+/**
+ * Content-addressed R2 storage via the native Workers binding (not S3 creds).
+ * Bytes live in the bucket under `{projectId}/{sha256}`; the `files` row records
+ * metadata + org linkage. `resolve` is org-scoped through `getFileInOrg` — the
+ * bare content id is never a lookup key, so one tenant cannot read another's
+ * bytes by knowing the hash (mirrors the local/s3 adapters).
+ */
+export function createR2Adapter(deps) {
+    const { db, bucket } = deps;
+    return {
+        async put(input) {
+            const id = createHash('sha256').update(input.bytes).digest('hex');
+            const body = new Uint8Array(input.bytes);
+            await bucket.put(objectKey(input.projectId, id), body, {
+                httpMetadata: { contentType: input.mime },
+                customMetadata: {
+                    filename: input.filename,
+                    mime: input.mime,
+                    projectId: input.projectId,
+                },
+            });
+            // Persist the metadata row so FileService.create can read it back and so
+            // resolve() can org-scope. Bytes stay in R2 (bytes: null in the DB).
+            await createFile(db, {
+                id,
+                projectId: input.projectId,
+                filename: input.filename,
+                mime: input.mime,
+                size: input.bytes.length,
+                bytes: null,
+                externalUrl: null,
+            });
+            return { id, url: fileUrl(id) };
+        },
+        async resolve(id) {
+            const auth = tryGetAuthContext();
+            if (auth === undefined || auth.kind === 'guest') {
+                return null;
+            }
+            const file = await getFileInOrg(db, id, auth.orgId);
+            if (!file) {
+                return null;
+            }
+            if (file.externalUrl) {
+                return { redirectUrl: file.externalUrl };
+            }
+            const obj = await bucket.get(objectKey(file.projectId, id));
+            if (obj === null) {
+                return null;
+            }
+            const bytes = Buffer.from(await obj.arrayBuffer());
+            return { bytes, mime: file.mime, filename: file.filename };
+        },
+    };
+}
+//# sourceMappingURL=r2.js.map

package/dist/worker.d.ts

@@ -3,10 +3,10 @@ export interface Env {
     PLANDESK_DB_URL: string;
     /** Turso/libSQL auth token — set via `wrangler secret put PLANDESK_DB_TOKEN` */
     PLANDESK_DB_TOKEN: string;
-    PLANDESK_S3_BUCKET: string;
-    PLANDESK_S3_REGION: string;
-    PLANDESK_S3_ACCESS_KEY_ID: string;
-    PLANDESK_S3_SECRET_ACCESS_KEY: string;
+    PLANDESK_S3_BUCKET?: string;
+    PLANDESK_S3_REGION?: string;
+    PLANDESK_S3_ACCESS_KEY_ID?: string;
+    PLANDESK_S3_SECRET_ACCESS_KEY?: string;
     PLANDESK_S3_ENDPOINT?: string;
     PLANDESK_AUTH_PASSWORD?: string;
     /**
@@ -32,8 +32,8 @@ export interface Env {
      */
     PLANDESK_GITHUB_CALLBACK_URL?: string;
     PLANDESK_DASHBOARD_URL?: string;
-    /** R2 bucket for file blobs (S3-compatible credentials above target this bucket). */
-    FILES: R2Bucket;
+    /** R2 bucket for file blobs (native Workers binding — preferred over S3 creds). */
+    FILES?: R2Bucket;
     /** Built web SPA (wrangler [assets]). */
     ASSETS?: Fetcher;
 }

package/dist/worker.js

@@ -9,19 +9,45 @@ import { createApp } from './server.js';
 import { createBetterAuth } from './better-auth.js';
 import { createServices } from './services/index.js';
 import { githubConfigFromEnv } from './github.js';
+import { createR2Adapter } from './storage/r2.js';
 import { createS3Adapter } from './storage/s3.js';
 import { hostedMisconfigResponse, resolveHostedBetterAuth } from './hosted-auth.js';
 let cache;
 let authCache;
 function s3ConfigFromEnv(env) {
+    const bucket = env.PLANDESK_S3_BUCKET;
+    const region = env.PLANDESK_S3_REGION;
+    const accessKeyId = env.PLANDESK_S3_ACCESS_KEY_ID;
+    const secretAccessKey = env.PLANDESK_S3_SECRET_ACCESS_KEY;
+    if (bucket === undefined ||
+        bucket === '' ||
+        region === undefined ||
+        region === '' ||
+        accessKeyId === undefined ||
+        accessKeyId === '' ||
+        secretAccessKey === undefined ||
+        secretAccessKey === '') {
+        return undefined;
+    }
     return {
-        bucket: env.PLANDESK_S3_BUCKET,
-        region: env.PLANDESK_S3_REGION,
-        accessKeyId: env.PLANDESK_S3_ACCESS_KEY_ID,
-        secretAccessKey: env.PLANDESK_S3_SECRET_ACCESS_KEY,
+        bucket,
+        region,
+        accessKeyId,
+        secretAccessKey,
         endpoint: env.PLANDESK_S3_ENDPOINT,
     };
 }
+function resolveWorkerStorage(env, db) {
+    // Prefer the native R2 binding over S3 credentials when present.
+    if (env.FILES !== undefined) {
+        return createR2Adapter({ db, bucket: env.FILES });
+    }
+    const s3 = s3ConfigFromEnv(env);
+    if (s3 !== undefined) {
+        return createS3Adapter({ db, config: s3 });
+    }
+    return undefined;
+}
 async function getDb(env) {
     const key = `${env.PLANDESK_DB_URL}\0${env.PLANDESK_DB_TOKEN}`;
     if (cache !== undefined && cache.key === key) {
@@ -83,12 +109,9 @@ export default {
         }
         const db = await getDb(env);
         const authInstance = await getBetterAuth(env, db, betterAuth);
-        // Storage is optional: only wire S3/R2 when its credentials are present.
-        // Without them the app still runs (file uploads/artifacts are unavailable),
-        // rather than throwing on every request — mirrors `plandesk serve`.
-        const storage = env.PLANDESK_S3_BUCKET !== undefined && env.PLANDESK_S3_BUCKET !== ''
-            ? createS3Adapter({ db, config: s3ConfigFromEnv(env) })
-            : undefined;
+        // Storage is optional: prefer R2 binding, then S3 creds, else unavailable
+        // (file uploads/artifacts off — no crash). Mirrors `plandesk serve`.
+        const storage = resolveWorkerStorage(env, db);
         const services = createServices({ db, ...(storage !== undefined ? { storage } : {}) });
         const app = createApp({
             db,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plandesk/api",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.3",
   "type": "module",
   "exports": {
     ".": {
@@ -26,7 +26,7 @@
     "@libsql/kysely-libsql": "^0.4.1",
     "better-auth": "1.6.23",
     "hono": "^4.12.23",
-    "@plandesk/db": "1.0.0-beta.2"
+    "@plandesk/db": "1.0.0-beta.3"
   },
   "description": "Plan Desk REST + SSE API and service layer (local-first planning workspace).",
   "license": "MIT",