@btst/stack 2.9.4 → 2.11.0

package/dist/shared/{stack.C7vfOBmO.d.mts → stack.C7u9lq9T.d.mts}

@@ -1,5 +1,5 @@
 import { DBAdapter } from '@btst/db';
-import { A as Asset, F as Folder } from './stack.CLcnSF_b.mjs';
+import { A as Asset, F as Folder } from './stack.BMlLOMED.mjs';
 
 /**
  * Parameters for filtering and paginating the asset list.
@@ -10,6 +10,7 @@ interface AssetListParams {
     query?: string;
     offset?: number;
     limit?: number;
+    tenantId?: string;
 }
 /**
  * Paginated result returned by {@link listAssets}.
@@ -25,6 +26,7 @@ interface AssetListResult {
  */
 interface FolderListParams {
     parentId?: string | null;
+    tenantId?: string;
 }
 /**
  * Retrieve all assets matching optional filter criteria.
@@ -58,6 +60,16 @@ declare function listFolders(adapter: DBAdapter, params?: FolderListParams): Pro
  * @remarks **Security:** Authorization hooks are NOT called.
  */
 declare function getFolderById(adapter: DBAdapter, id: string): Promise<Folder | null>;
+/**
+ * Find a single folder by name, optionally scoped to a specific parent and/or tenant.
+ * Pass `null` for `parentId` to search only root-level folders.
+ * Pass `undefined` for `parentId` to search regardless of parent.
+ * Returns `null` if no matching folder is found.
+ *
+ * Pure DB function — no hooks, no HTTP context.
+ * The caller is responsible for any access-control checks.
+ */
+declare function getFolderByName(adapter: DBAdapter, name: string, parentId?: string | null, tenantId?: string): Promise<Folder | null>;
 
-export { listFolders as a, getFolderById as b, getAssetById as g, listAssets as l };
-export type { AssetListParams as A, FolderListParams as F, AssetListResult as c };
+export { listFolders as a, getFolderById as b, getFolderByName as c, getAssetById as g, listAssets as l };
+export type { AssetListParams as A, FolderListParams as F, AssetListResult as d };

package/dist/shared/{stack.DYrJsJ7x.d.mts → stack.C_MUwwgR.d.mts}

@@ -1,9 +1,9 @@
 import * as _btst_stack_plugins_api from '@btst/stack/plugins/api';
 import { a as StorageAdapter, b as S3UploadToken } from './stack.DO6vOGQG.mjs';
-import { c as AssetListResult, l as listAssets, a as listFolders, A as AssetListParams } from './stack.C7vfOBmO.mjs';
+import { d as AssetListResult, l as listAssets, a as listFolders, A as AssetListParams } from './stack.C7u9lq9T.mjs';
 import * as better_call from 'better-call';
 import { z } from 'zod';
-import { A as Asset, F as Folder } from './stack.CLcnSF_b.mjs';
+import { A as Asset, F as Folder } from './stack.BMlLOMED.mjs';
 
 declare const AssetListQuerySchema: z.ZodObject<{
     folderId: z.ZodOptional<z.ZodString>;
@@ -124,6 +124,23 @@ interface MediaBackendConfig {
      * Optional lifecycle hooks for the media backend plugin.
      */
     hooks?: MediaBackendHooks;
+    /**
+     * Optional function to resolve a tenant ID from the incoming request context.
+     *
+     * When provided, all asset and folder list/create operations through the HTTP
+     * API are automatically scoped to the returned tenant ID:
+     * - GET /media/assets  →  filters results to the resolved tenant
+     * - POST /media/assets →  tags the created asset with the resolved tenant
+     * - POST /media/upload →  tags the uploaded asset with the resolved tenant
+     * - GET /media/folders →  filters results to the resolved tenant
+     * - POST /media/folders → tags the created folder with the resolved tenant
+     *
+     * When absent, no tenant filtering is applied (existing behaviour).
+     *
+     * Returning `null` or `undefined` means "no tenant" for this request —
+     * the operation proceeds without tenant scoping (useful for super-admin routes).
+     */
+    resolveTenantId?: (context: MediaApiContext) => Promise<string | null | undefined> | string | null | undefined;
 }
 /**
  * Media backend plugin.
@@ -255,6 +272,7 @@ declare const mediaBackendPlugin: (config: MediaBackendConfig) => _btst_stack_pl
     getAssetById: (id: string) => Promise<Asset | null>;
     listFolders: (params?: Parameters<typeof listFolders>[1]) => Promise<Folder[]>;
     getFolderById: (id: string) => Promise<Folder | null>;
+    getFolderByName: (name: string, parentId?: string | null, tenantId?: string) => Promise<Folder | null>;
 }>;
 type MediaApiRouter = ReturnType<ReturnType<typeof mediaBackendPlugin>["routes"]>;
 

package/dist/shared/{stack.BinHXe1r.d.cts → stack.D6zyQnMo.d.cts}

@@ -1,9 +1,9 @@
 import * as _btst_stack_plugins_api from '@btst/stack/plugins/api';
 import { a as StorageAdapter, b as S3UploadToken } from './stack.DO6vOGQG.cjs';
-import { c as AssetListResult, l as listAssets, a as listFolders, A as AssetListParams } from './stack.CAni8dnD.cjs';
+import { d as AssetListResult, l as listAssets, a as listFolders, A as AssetListParams } from './stack.jU2iG86n.cjs';
 import * as better_call from 'better-call';
 import { z } from 'zod';
-import { A as Asset, F as Folder } from './stack.CLcnSF_b.cjs';
+import { A as Asset, F as Folder } from './stack.BMlLOMED.cjs';
 
 declare const AssetListQuerySchema: z.ZodObject<{
     folderId: z.ZodOptional<z.ZodString>;
@@ -124,6 +124,23 @@ interface MediaBackendConfig {
      * Optional lifecycle hooks for the media backend plugin.
      */
     hooks?: MediaBackendHooks;
+    /**
+     * Optional function to resolve a tenant ID from the incoming request context.
+     *
+     * When provided, all asset and folder list/create operations through the HTTP
+     * API are automatically scoped to the returned tenant ID:
+     * - GET /media/assets  →  filters results to the resolved tenant
+     * - POST /media/assets →  tags the created asset with the resolved tenant
+     * - POST /media/upload →  tags the uploaded asset with the resolved tenant
+     * - GET /media/folders →  filters results to the resolved tenant
+     * - POST /media/folders → tags the created folder with the resolved tenant
+     *
+     * When absent, no tenant filtering is applied (existing behaviour).
+     *
+     * Returning `null` or `undefined` means "no tenant" for this request —
+     * the operation proceeds without tenant scoping (useful for super-admin routes).
+     */
+    resolveTenantId?: (context: MediaApiContext) => Promise<string | null | undefined> | string | null | undefined;
 }
 /**
  * Media backend plugin.
@@ -255,6 +272,7 @@ declare const mediaBackendPlugin: (config: MediaBackendConfig) => _btst_stack_pl
     getAssetById: (id: string) => Promise<Asset | null>;
     listFolders: (params?: Parameters<typeof listFolders>[1]) => Promise<Folder[]>;
     getFolderById: (id: string) => Promise<Folder | null>;
+    getFolderByName: (name: string, parentId?: string | null, tenantId?: string) => Promise<Folder | null>;
 }>;
 type MediaApiRouter = ReturnType<ReturnType<typeof mediaBackendPlugin>["routes"]>;
 

package/dist/shared/{stack.CYSwntXC.d.ts → stack.DD-ZORI7.d.ts}

@@ -1,5 +1,5 @@
 import { DBAdapter } from '@btst/db';
-import { A as Asset, F as Folder } from './stack.CLcnSF_b.js';
+import { A as Asset, F as Folder } from './stack.BMlLOMED.js';
 
 /**
  * Parameters for filtering and paginating the asset list.
@@ -10,6 +10,7 @@ interface AssetListParams {
     query?: string;
     offset?: number;
     limit?: number;
+    tenantId?: string;
 }
 /**
  * Paginated result returned by {@link listAssets}.
@@ -25,6 +26,7 @@ interface AssetListResult {
  */
 interface FolderListParams {
     parentId?: string | null;
+    tenantId?: string;
 }
 /**
  * Retrieve all assets matching optional filter criteria.
@@ -58,6 +60,16 @@ declare function listFolders(adapter: DBAdapter, params?: FolderListParams): Pro
  * @remarks **Security:** Authorization hooks are NOT called.
  */
 declare function getFolderById(adapter: DBAdapter, id: string): Promise<Folder | null>;
+/**
+ * Find a single folder by name, optionally scoped to a specific parent and/or tenant.
+ * Pass `null` for `parentId` to search only root-level folders.
+ * Pass `undefined` for `parentId` to search regardless of parent.
+ * Returns `null` if no matching folder is found.
+ *
+ * Pure DB function — no hooks, no HTTP context.
+ * The caller is responsible for any access-control checks.
+ */
+declare function getFolderByName(adapter: DBAdapter, name: string, parentId?: string | null, tenantId?: string): Promise<Folder | null>;
 
-export { listFolders as a, getFolderById as b, getAssetById as g, listAssets as l };
-export type { AssetListParams as A, FolderListParams as F, AssetListResult as c };
+export { listFolders as a, getFolderById as b, getFolderByName as c, getAssetById as g, listAssets as l };
+export type { AssetListParams as A, FolderListParams as F, AssetListResult as d };

package/dist/shared/{stack.CAni8dnD.d.cts → stack.jU2iG86n.d.cts}

@@ -1,5 +1,5 @@
 import { DBAdapter } from '@btst/db';
-import { A as Asset, F as Folder } from './stack.CLcnSF_b.cjs';
+import { A as Asset, F as Folder } from './stack.BMlLOMED.cjs';
 
 /**
  * Parameters for filtering and paginating the asset list.
@@ -10,6 +10,7 @@ interface AssetListParams {
     query?: string;
     offset?: number;
     limit?: number;
+    tenantId?: string;
 }
 /**
  * Paginated result returned by {@link listAssets}.
@@ -25,6 +26,7 @@ interface AssetListResult {
  */
 interface FolderListParams {
     parentId?: string | null;
+    tenantId?: string;
 }
 /**
  * Retrieve all assets matching optional filter criteria.
@@ -58,6 +60,16 @@ declare function listFolders(adapter: DBAdapter, params?: FolderListParams): Pro
  * @remarks **Security:** Authorization hooks are NOT called.
  */
 declare function getFolderById(adapter: DBAdapter, id: string): Promise<Folder | null>;
+/**
+ * Find a single folder by name, optionally scoped to a specific parent and/or tenant.
+ * Pass `null` for `parentId` to search only root-level folders.
+ * Pass `undefined` for `parentId` to search regardless of parent.
+ * Returns `null` if no matching folder is found.
+ *
+ * Pure DB function — no hooks, no HTTP context.
+ * The caller is responsible for any access-control checks.
+ */
+declare function getFolderByName(adapter: DBAdapter, name: string, parentId?: string | null, tenantId?: string): Promise<Folder | null>;
 
-export { listFolders as a, getFolderById as b, getAssetById as g, listAssets as l };
-export type { AssetListParams as A, FolderListParams as F, AssetListResult as c };
+export { listFolders as a, getFolderById as b, getFolderByName as c, getAssetById as g, listAssets as l };
+export type { AssetListParams as A, FolderListParams as F, AssetListResult as d };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@btst/stack",
-  "version": "2.9.4",
+  "version": "2.11.0",
   "description": "A composable, plugin-based library for building full-stack applications.",
   "repository": {
     "type": "git",

package/src/plugins/media/__tests__/getters.test.ts

@@ -8,6 +8,7 @@ import {
 	getAssetById,
 	listFolders,
 	getFolderById,
+	getFolderByName,
 } from "../api/getters";
 
 const createTestAdapter = (): Adapter => {
@@ -162,6 +163,30 @@ describe("media getters", () => {
 			expect(photoResult.items[0]!.filename).toBe("holiday-photo.jpg");
 		});
 
+		it("filters assets by tenantId", async () => {
+			await adapter.create({
+				model: "mediaAsset",
+				data: makeAsset({
+					filename: "tenant-a.jpg",
+					url: "https://example.com/a.jpg",
+				}),
+			});
+			const assetB = await adapter.create<{ id: string }>({
+				model: "mediaAsset",
+				data: {
+					...makeAsset({
+						filename: "tenant-b.jpg",
+						url: "https://example.com/b.jpg",
+					}),
+					tenantId: "tenant-b",
+				},
+			});
+
+			const result = await listAssets(adapter, { tenantId: "tenant-b" });
+			expect(result.items).toHaveLength(1);
+			expect(result.items[0]!.id).toBe(assetB.id);
+		});
+
 		it("paginates results with limit and offset", async () => {
 			for (let i = 0; i < 5; i++) {
 				await adapter.create({
@@ -231,6 +256,24 @@ describe("media getters", () => {
 			expect(result[1]!.name).toBe("Zeta");
 		});
 
+		it("filters folders by tenantId", async () => {
+			await adapter.create({
+				model: "mediaFolder",
+				data: makeFolder({ name: "No Tenant" }),
+			});
+			const tenantFolder = await adapter.create<{ id: string }>({
+				model: "mediaFolder",
+				data: {
+					...makeFolder({ name: "Tenant Folder" }),
+					tenantId: "tenant-x",
+				},
+			});
+
+			const result = await listFolders(adapter, { tenantId: "tenant-x" });
+			expect(result).toHaveLength(1);
+			expect(result[0]!.id).toBe(tenantFolder.id);
+		});
+
 		it("filters folders by parentId", async () => {
 			const root = await adapter.create<{ id: string }>({
 				model: "mediaFolder",
@@ -271,4 +314,116 @@ describe("media getters", () => {
 			expect(result!.name).toBe("Test Folder");
 		});
 	});
+
+	// ── getFolderByName ───────────────────────────────────────────────────────
+
+	describe("getFolderByName", () => {
+		it("returns null when no folder exists", async () => {
+			const result = await getFolderByName(adapter, "nonexistent");
+			expect(result).toBeNull();
+		});
+
+		it("finds a root-level folder by name with no parentId constraint", async () => {
+			await adapter.create({
+				model: "mediaFolder",
+				data: makeFolder({ name: "blog-gen-profile-1" }),
+			});
+
+			const result = await getFolderByName(adapter, "blog-gen-profile-1");
+			expect(result).not.toBeNull();
+			expect(result!.name).toBe("blog-gen-profile-1");
+		});
+
+		it("returns null when name matches but parentId does not", async () => {
+			const parent = await adapter.create<{ id: string }>({
+				model: "mediaFolder",
+				data: makeFolder({ name: "Parent" }),
+			});
+			await adapter.create({
+				model: "mediaFolder",
+				data: makeFolder({ name: "Child", parentId: parent.id }),
+			});
+
+			// Search for "Child" scoped to a different (non-existent) parent.
+			const result = await getFolderByName(adapter, "Child", "wrong-parent-id");
+			expect(result).toBeNull();
+		});
+
+		it("scopes lookup to root-level folders when parentId is null", async () => {
+			// Explicitly store parentId as null (mirrors how SQL adapters persist root folders).
+			const rootFolder = await adapter.create<{ id: string }>({
+				model: "mediaFolder",
+				data: { ...makeFolder({ name: "Images" }), parentId: null },
+			});
+			// A nested folder with the same name.
+			await adapter.create({
+				model: "mediaFolder",
+				data: makeFolder({ name: "Images", parentId: rootFolder.id }),
+			});
+
+			// Only the root-level "Images" (parentId = null) should be returned.
+			const result = await getFolderByName(adapter, "Images", null);
+			expect(result).not.toBeNull();
+			expect(result!.id).toBe(rootFolder.id);
+		});
+
+		it("finds a child folder scoped to the correct parentId", async () => {
+			const parentA = await adapter.create<{ id: string }>({
+				model: "mediaFolder",
+				data: makeFolder({ name: "Parent A" }),
+			});
+			const parentB = await adapter.create<{ id: string }>({
+				model: "mediaFolder",
+				data: makeFolder({ name: "Parent B" }),
+			});
+			const childOfA = await adapter.create<{ id: string }>({
+				model: "mediaFolder",
+				data: makeFolder({ name: "Child", parentId: parentA.id }),
+			});
+			await adapter.create({
+				model: "mediaFolder",
+				data: makeFolder({ name: "Child", parentId: parentB.id }),
+			});
+
+			const result = await getFolderByName(adapter, "Child", parentA.id);
+			expect(result).not.toBeNull();
+			expect(result!.id).toBe(childOfA.id);
+		});
+
+		it("filters by tenantId when provided", async () => {
+			await adapter.create({
+				model: "mediaFolder",
+				data: { ...makeFolder({ name: "blog-gen-abc" }), tenantId: "tenant-1" },
+			});
+			const folderT2 = await adapter.create<{ id: string }>({
+				model: "mediaFolder",
+				data: { ...makeFolder({ name: "blog-gen-abc" }), tenantId: "tenant-2" },
+			});
+
+			// Same name, different tenant — should only return the matching one.
+			const result = await getFolderByName(
+				adapter,
+				"blog-gen-abc",
+				undefined,
+				"tenant-2",
+			);
+			expect(result).not.toBeNull();
+			expect(result!.id).toBe(folderT2.id);
+		});
+
+		it("returns null when tenantId does not match", async () => {
+			await adapter.create({
+				model: "mediaFolder",
+				data: { ...makeFolder({ name: "blog-gen-xyz" }), tenantId: "tenant-1" },
+			});
+
+			const result = await getFolderByName(
+				adapter,
+				"blog-gen-xyz",
+				undefined,
+				"tenant-999",
+			);
+			expect(result).toBeNull();
+		});
+	});
 });

package/src/plugins/media/__tests__/mutations.test.ts

@@ -59,6 +59,21 @@ describe("media mutations", () => {
 			expect(asset.alt).toBe("A beautiful photo");
 		});
 
+		it("persists tenantId when provided", async () => {
+			const asset = await createAsset(adapter, {
+				...assetInput,
+				tenantId: "profile-abc",
+			});
+
+			expect(asset.tenantId).toBe("profile-abc");
+		});
+
+		it("leaves tenantId absent when not provided", async () => {
+			const asset = await createAsset(adapter, assetInput);
+
+			expect(asset.tenantId == null).toBe(true);
+		});
+
 		it("creates multiple independent assets", async () => {
 			await createAsset(adapter, {
 				...assetInput,
@@ -194,6 +209,21 @@ describe("media mutations", () => {
 			expect(folder.createdAt).toBeInstanceOf(Date);
 		});
 
+		it("persists tenantId when provided", async () => {
+			const folder = await createFolder(adapter, {
+				name: "Tenant Folder",
+				tenantId: "profile-xyz",
+			});
+
+			expect(folder.tenantId).toBe("profile-xyz");
+		});
+
+		it("leaves tenantId absent when not provided", async () => {
+			const folder = await createFolder(adapter, { name: "No Tenant" });
+
+			expect(folder.tenantId == null).toBe(true);
+		});
+
 		it("creates a nested folder with parentId", async () => {
 			const parent = await createFolder(adapter, { name: "Root" });
 			const child = await createFolder(adapter, {

package/src/plugins/media/api/adapters/local.ts

@@ -1,6 +1,6 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import * as crypto from "node:crypto";
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as crypto from "crypto";
 import type { DirectStorageAdapter, UploadOptions } from "../storage-adapter";
 
 export interface LocalStorageAdapterOptions {

package/src/plugins/media/api/getters.ts

@@ -10,6 +10,7 @@ export interface AssetListParams {
 	query?: string;
 	offset?: number;
 	limit?: number;
+	tenantId?: string;
 }
 
 /**
@@ -27,6 +28,7 @@ export interface AssetListResult {
  */
 export interface FolderListParams {
 	parentId?: string | null;
+	tenantId?: string;
 }
 
 /**
@@ -64,6 +66,14 @@ export async function listAssets(
 		});
 	}
 
+	if (query.tenantId !== undefined) {
+		whereConditions.push({
+			field: "tenantId",
+			value: query.tenantId,
+			operator: "eq" as const,
+		});
+	}
+
 	const needsInMemoryFilter = !!query.query;
 	const dbWhere = whereConditions.length > 0 ? whereConditions : undefined;
 
@@ -136,22 +146,31 @@ export async function listFolders(
 	adapter: Adapter,
 	params?: FolderListParams,
 ): Promise<Folder[]> {
-	// Only add a where clause when parentId is explicitly provided as a string.
-	// Passing undefined (or no params) returns all folders unfiltered.
-	const where =
-		params?.parentId !== undefined
-			? [
-					{
-						field: "parentId",
-						value: params.parentId,
-						operator: "eq" as const,
-					},
-				]
-			: undefined;
+	const whereConditions: Array<{
+		field: string;
+		value: string | null;
+		operator: "eq";
+	}> = [];
+
+	if (params?.parentId !== undefined) {
+		whereConditions.push({
+			field: "parentId",
+			value: params.parentId,
+			operator: "eq" as const,
+		});
+	}
+
+	if (params?.tenantId !== undefined) {
+		whereConditions.push({
+			field: "tenantId",
+			value: params.tenantId,
+			operator: "eq" as const,
+		});
+	}
 
 	return adapter.findMany<Folder>({
 		model: "mediaFolder",
-		where,
+		where: whereConditions.length > 0 ? whereConditions : undefined,
 		sortBy: { field: "name", direction: "asc" },
 	});
 }
@@ -172,3 +191,35 @@ export async function getFolderById(
 		where: [{ field: "id", value: id, operator: "eq" as const }],
 	});
 }
+
+/**
+ * Find a single folder by name, optionally scoped to a specific parent and/or tenant.
+ * Pass `null` for `parentId` to search only root-level folders.
+ * Pass `undefined` for `parentId` to search regardless of parent.
+ * Returns `null` if no matching folder is found.
+ *
+ * Pure DB function — no hooks, no HTTP context.
+ * The caller is responsible for any access-control checks.
+ */
+export async function getFolderByName(
+	adapter: Adapter,
+	name: string,
+	parentId?: string | null,
+	tenantId?: string,
+): Promise<Folder | null> {
+	const where: Array<{
+		field: string;
+		value: string | null;
+		operator: "eq";
+	}> = [{ field: "name", value: name, operator: "eq" as const }];
+
+	if (parentId !== undefined) {
+		where.push({ field: "parentId", value: parentId, operator: "eq" as const });
+	}
+
+	if (tenantId !== undefined) {
+		where.push({ field: "tenantId", value: tenantId, operator: "eq" as const });
+	}
+
+	return adapter.findOne<Folder>({ model: "mediaFolder", where });
+}

package/src/plugins/media/api/index.ts

@@ -5,6 +5,7 @@ export {
 	getAssetById,
 	listFolders,
 	getFolderById,
+	getFolderByName,
 	type AssetListParams,
 	type AssetListResult,
 	type FolderListParams,

package/src/plugins/media/api/mutations.ts

@@ -12,6 +12,7 @@ export interface CreateAssetInput {
 	url: string;
 	folderId?: string;
 	alt?: string;
+	tenantId?: string;
 }
 
 /**
@@ -28,6 +29,7 @@ export interface UpdateAssetInput {
 export interface CreateFolderInput {
 	name: string;
 	parentId?: string;
+	tenantId?: string;
 }
 
 /**
@@ -51,6 +53,7 @@ export async function createAsset(
 			url: input.url,
 			folderId: input.folderId,
 			alt: input.alt,
+			tenantId: input.tenantId,
 			createdAt: new Date(),
 		},
 	});
@@ -114,6 +117,7 @@ export async function createFolder(
 		data: {
 			name: input.name,
 			parentId: input.parentId,
+			tenantId: input.tenantId,
 			createdAt: new Date(),
 		},
 	});