@btst/stack 3.0.0-rc.2 → 3.0.0-rc.3

package/dist/packages/stack/src/plugins/kanban/client/plugin.mjs

@@ -1,15 +1,75 @@
 import { jsx } from 'react/jsx-runtime';
-import { defineClientPlugin, createApiClient, isConnectionError } from '@btst/stack/plugins/client';
+import { defineClientPlugin, createApiClient, isErrorResponse, isConnectionError } from '@btst/stack/plugins/client';
+import { normalizePath } from '@btst/stack/client';
 import { defineRoutes, defineRoute } from '@btst/yar';
+import { lazy } from 'react';
 import { createKanbanQueryKeys } from '../../../../../../plugins/kanban/query-keys.mjs';
-import { BoardsListPageComponent } from './components/pages/boards-list-page.mjs';
-import { NewBoardPageComponent } from './components/pages/new-board-page.mjs';
-import { BoardPageComponent } from './components/pages/board-page.mjs';
+import { createSanitizedSSRLoaderError } from '../../utils.mjs';
+import { KANBAN_PLUGIN_ID } from './constants.mjs';
 
+const BoardsListPageComponent = lazy(
+  () => import('./components/pages/boards-list-page.mjs').then((module) => ({
+    default: module.BoardsListPageComponent
+  }))
+);
+const NewBoardPageComponent = lazy(
+  () => import('./components/pages/new-board-page.mjs').then((module) => ({
+    default: module.NewBoardPageComponent
+  }))
+);
+const BoardPageComponent = lazy(
+  () => import('./components/pages/board-page.mjs').then((module) => ({
+    default: module.BoardPageComponent
+  }))
+);
+function resolveKanbanClientConfig(config, runtime) {
+  return {
+    seo: config.seo,
+    hooks: config.hooks,
+    identityPartition: config.identityPartition,
+    pageComponents: config.pageComponents,
+    apiBaseURL: runtime.api.baseURL,
+    apiBasePath: runtime.api.basePath,
+    siteBaseURL: runtime.site.baseURL,
+    siteBasePath: runtime.site.basePath,
+    queryClient: runtime.queryClient,
+    ...runtime.api.headers ? { headers: runtime.api.headers } : {},
+    ...runtime.api.credentials ? { credentials: runtime.api.credentials } : {}
+  };
+}
+function createKanbanApiClient(config) {
+  return createApiClient({
+    baseURL: config.apiBaseURL,
+    basePath: config.apiBasePath,
+    headers: config.headers,
+    credentials: config.credentials
+  });
+}
+function createLoadErrorReporter(hooks, context) {
+  let reported = false;
+  return async (error) => {
+    if (reported || !hooks?.onErrorLoad) return;
+    reported = true;
+    try {
+      await hooks.onErrorLoad(
+        error instanceof Error ? error : new Error(String(error)),
+        context
+      );
+    } catch {
+    }
+  };
+}
 function createBoardsLoader(config) {
   return async () => {
     if (typeof window === "undefined") {
-      const { queryClient, apiBasePath, apiBaseURL, hooks, headers } = config;
+      const {
+        queryClient,
+        apiBasePath,
+        apiBaseURL,
+        hooks,
+        headers,
+        identityPartition
+      } = config;
       const context = {
         path: "/kanban",
         isSSR: true,
@@ -17,16 +77,13 @@ function createBoardsLoader(config) {
         apiBasePath,
         headers
       };
+      const reportError = createLoadErrorReporter(hooks, context);
+      const queries = createKanbanQueryKeys(createKanbanApiClient(config));
+      const listQuery = queries.boards.list({}, identityPartition);
       try {
         if (hooks?.beforeLoadBoards) {
           await hooks.beforeLoadBoards(context);
         }
-        const client = createApiClient({
-          baseURL: apiBaseURL,
-          basePath: apiBasePath
-        });
-        const queries = createKanbanQueryKeys(client, headers);
-        const listQuery = queries.boards.list({});
         await queryClient.prefetchQuery(listQuery);
         if (hooks?.afterLoadBoards) {
           const boards = queryClient.getQueryData(
@@ -35,19 +92,25 @@ function createBoardsLoader(config) {
           await hooks.afterLoadBoards(boards || null, context);
         }
         const queryState = queryClient.getQueryState(listQuery.queryKey);
-        if (queryState?.error && hooks?.onLoadError) {
-          const error = queryState.error instanceof Error ? queryState.error : new Error(String(queryState.error));
-          await hooks.onLoadError(error, context);
+        if (queryState?.error) {
+          await reportError(queryState.error);
         }
       } catch (error) {
         if (isConnectionError(error)) {
           console.warn(
-            "[btst/kanban] route.loader() failed \u2014 no server running at build time. Use myStack.api.kanban.prefetchForRoute() for SSG data prefetching."
+            "[btst/kanban] route.loader() failed \u2014 no server running at build time. Use myStack.raw.kanban.prefetchForRoute() for SSG data prefetching."
           );
+        } else {
+          const errToStore = createSanitizedSSRLoaderError();
+          await queryClient.prefetchQuery({
+            queryKey: listQuery.queryKey,
+            queryFn: () => {
+              throw errToStore;
+            },
+            retry: false
+          });
         }
-        if (hooks?.onLoadError) {
-          await hooks.onLoadError(error, context);
-        }
+        await reportError(error);
       }
     }
   };
@@ -55,7 +118,14 @@ function createBoardsLoader(config) {
 function createBoardLoader(boardId, config) {
   return async () => {
     if (typeof window === "undefined") {
-      const { queryClient, apiBasePath, apiBaseURL, hooks, headers } = config;
+      const {
+        queryClient,
+        apiBasePath,
+        apiBaseURL,
+        hooks,
+        headers,
+        identityPartition
+      } = config;
       const context = {
         path: `/kanban/${boardId}`,
         params: { boardId },
@@ -64,16 +134,13 @@ function createBoardLoader(boardId, config) {
         apiBasePath,
         headers
       };
+      const reportError = createLoadErrorReporter(hooks, context);
+      const queries = createKanbanQueryKeys(createKanbanApiClient(config));
+      const boardQuery = queries.boards.detail(boardId, identityPartition);
       try {
         if (hooks?.beforeLoadBoard) {
           await hooks.beforeLoadBoard(boardId, context);
         }
-        const client = createApiClient({
-          baseURL: apiBaseURL,
-          basePath: apiBasePath
-        });
-        const queries = createKanbanQueryKeys(client, headers);
-        const boardQuery = queries.boards.detail(boardId);
         await queryClient.prefetchQuery(boardQuery);
         if (hooks?.afterLoadBoard) {
           const board = queryClient.getQueryData(
@@ -82,19 +149,25 @@ function createBoardLoader(boardId, config) {
           await hooks.afterLoadBoard(board || null, boardId, context);
         }
         const queryState = queryClient.getQueryState(boardQuery.queryKey);
-        if (queryState?.error && hooks?.onLoadError) {
-          const error = queryState.error instanceof Error ? queryState.error : new Error(String(queryState.error));
-          await hooks.onLoadError(error, context);
+        if (queryState?.error) {
+          await reportError(queryState.error);
         }
       } catch (error) {
         if (isConnectionError(error)) {
           console.warn(
-            "[btst/kanban] route.loader() failed \u2014 no server running at build time. Use myStack.api.kanban.prefetchForRoute() for SSG data prefetching."
+            "[btst/kanban] route.loader() failed \u2014 no server running at build time. Use myStack.raw.kanban.prefetchForRoute() for SSG data prefetching."
           );
+        } else {
+          const errToStore = createSanitizedSSRLoaderError();
+          await queryClient.prefetchQuery({
+            queryKey: boardQuery.queryKey,
+            queryFn: () => {
+              throw errToStore;
+            },
+            retry: false
+          });
         }
-        if (hooks?.onLoadError) {
-          await hooks.onLoadError(error, context);
-        }
+        await reportError(error);
       }
     }
   };
@@ -110,6 +183,7 @@ function createNewBoardLoader(config) {
         apiBasePath,
         headers
       };
+      const reportError = createLoadErrorReporter(hooks, context);
       try {
         if (hooks?.beforeLoadNewBoard) {
           await hooks.beforeLoadNewBoard(context);
@@ -118,9 +192,7 @@ function createNewBoardLoader(config) {
           await hooks.afterLoadNewBoard(context);
         }
       } catch (error) {
-        if (hooks?.onLoadError) {
-          await hooks.onLoadError(error, context);
-        }
+        await reportError(error);
       }
     }
   };
@@ -128,7 +200,9 @@ function createNewBoardLoader(config) {
 function createBoardsListMeta(config) {
   return () => {
     const { siteBaseURL, siteBasePath, seo } = config;
-    const fullUrl = `${siteBaseURL}${siteBasePath}/kanban`;
+    const fullUrl = `${siteBaseURL}${normalizePath(
+      [siteBasePath, "kanban"].join("/")
+    )}`;
     const title = "Kanban Boards";
     const description = seo?.description || "Manage your projects with kanban boards";
     return [
@@ -151,22 +225,10 @@ function createBoardsListMeta(config) {
 }
 function createBoardMeta(boardId, config) {
   return () => {
-    const {
-      queryClient,
-      apiBaseURL,
-      apiBasePath,
-      siteBaseURL,
-      siteBasePath,
-      seo
-    } = config;
-    const queries = createKanbanQueryKeys(
-      createApiClient({
-        baseURL: apiBaseURL,
-        basePath: apiBasePath
-      })
-    );
+    const { queryClient, siteBaseURL, siteBasePath, seo, identityPartition } = config;
+    const queries = createKanbanQueryKeys(createKanbanApiClient(config));
     const board = queryClient.getQueryData(
-      queries.boards.detail(boardId).queryKey
+      queries.boards.detail(boardId, identityPartition).queryKey
     );
     if (!board) {
       return [
@@ -174,7 +236,9 @@ function createBoardMeta(boardId, config) {
         { name: "robots", content: "noindex" }
       ];
     }
-    const fullUrl = `${siteBaseURL}${siteBasePath}/kanban/${board.id}`;
+    const fullUrl = `${siteBaseURL}${normalizePath(
+      [siteBasePath, "kanban", board.id].join("/")
+    )}`;
     const title = board.name;
     const description = board.description || `Kanban board: ${board.name}`;
     return [
@@ -196,7 +260,9 @@ function createBoardMeta(boardId, config) {
 function createNewBoardMeta(config) {
   return () => {
     const { siteBaseURL, siteBasePath } = config;
-    const fullUrl = `${siteBaseURL}${siteBasePath}/kanban/new`;
+    const fullUrl = `${siteBaseURL}${normalizePath(
+      [siteBasePath, "kanban", "new"].join("/")
+    )}`;
     const title = "Create New Board";
     return [
       { title },
@@ -211,60 +277,67 @@ function createNewBoardMeta(config) {
     ];
   };
 }
-const kanbanClientPlugin = (config) => defineClientPlugin({
-  name: "kanban",
-  routes: () => defineRoutes(
-    {
-      boards: defineRoute("/kanban", {
-        page: BoardsListPageComponent,
-        loader: createBoardsLoader(config),
-        meta: createBoardsListMeta(config)
-      }),
-      newBoard: defineRoute("/kanban/new", {
-        page: NewBoardPageComponent,
-        loader: createNewBoardLoader(config),
-        meta: createNewBoardMeta(config)
-      }),
-      board: defineRoute("/kanban/:boardId", {
-        page: ({ params }) => /* @__PURE__ */ jsx(BoardPageComponent, { boardId: params.boardId }),
-        loader: ({ params }) => createBoardLoader(params.boardId, config)(),
-        meta: ({ params }) => createBoardMeta(params.boardId, config)()
-      })
-    },
-    { pages: config.pageComponents }
-  ),
-  sitemap: async () => {
-    const origin = `${config.siteBaseURL}${config.siteBasePath}`;
-    const indexUrl = `${origin}/kanban`;
-    const client = createApiClient({
-      baseURL: config.apiBaseURL,
-      basePath: config.apiBasePath
-    });
-    let boards = [];
-    try {
-      const res = await client("/boards", {
-        method: "GET",
-        query: { limit: 100 }
-      });
-      boards = res.data?.items ?? [];
-    } catch {
-    }
-    const entries = [
+function createResolvedKanbanPlugin(config) {
+  return {
+    routes: () => defineRoutes(
       {
-        url: indexUrl,
-        lastModified: /* @__PURE__ */ new Date(),
-        changeFrequency: "daily",
-        priority: 0.7
+        boards: defineRoute("/kanban", {
+          page: BoardsListPageComponent,
+          loader: createBoardsLoader(config),
+          meta: createBoardsListMeta(config)
+        }),
+        newBoard: defineRoute("/kanban/new", {
+          page: NewBoardPageComponent,
+          loader: createNewBoardLoader(config),
+          meta: createNewBoardMeta(config)
+        }),
+        board: defineRoute("/kanban/:boardId", {
+          page: ({ params }) => /* @__PURE__ */ jsx(BoardPageComponent, { boardId: params.boardId }),
+          loader: ({ params }) => createBoardLoader(params.boardId, config)(),
+          meta: ({ params }) => createBoardMeta(params.boardId, config)()
+        })
       },
-      ...boards.map((b) => ({
-        url: `${origin}/kanban/${b.id}`,
-        lastModified: b.updatedAt ? new Date(b.updatedAt) : void 0,
-        changeFrequency: "weekly",
-        priority: 0.6
-      }))
-    ];
-    return entries;
-  }
+      { pages: config.pageComponents }
+    ),
+    sitemap: async () => {
+      const origin = `${config.siteBaseURL}${normalizePath(
+        config.siteBasePath
+      )}`.replace(/\/$/, "");
+      const indexUrl = `${origin}/kanban`;
+      const client = createApiClient({
+        baseURL: config.apiBaseURL,
+        basePath: config.apiBasePath
+      });
+      try {
+        const res = await client("/boards", {
+          method: "GET",
+          query: { limit: 100 }
+        });
+        if (isErrorResponse(res)) return [];
+        const boards = res.data?.items ?? [];
+        return [
+          {
+            url: indexUrl,
+            lastModified: /* @__PURE__ */ new Date(),
+            changeFrequency: "daily",
+            priority: 0.7
+          },
+          ...boards.map((b) => ({
+            url: `${origin}/kanban/${b.id}`,
+            lastModified: b.updatedAt ? new Date(b.updatedAt) : void 0,
+            changeFrequency: "weekly",
+            priority: 0.6
+          }))
+        ];
+      } catch {
+        return [];
+      }
+    }
+  };
+}
+const kanbanClientPlugin = (config = {}) => defineClientPlugin()({
+  id: KANBAN_PLUGIN_ID,
+  resolve: (runtime) => createResolvedKanbanPlugin(resolveKanbanClientConfig(config, runtime))
 });
 
 export { kanbanClientPlugin };

package/dist/packages/stack/src/plugins/kanban/schemas.cjs

@@ -14,57 +14,69 @@ const boardCoreFields = {
   ownerId: z.z.string().optional(),
   organizationId: z.z.string().optional()
 };
-const BoardDomainSchema = z.z.object({
+const boardOperationFields = {
+  name: boardCoreFields.name,
+  slug: boardCoreFields.slug,
+  description: boardCoreFields.description
+};
+z.z.object({
   id: z.z.string().optional(),
   ...boardCoreFields,
   ...boardDateFields
 });
-const createBoardSchema = BoardDomainSchema.extend({
-  slug: BoardDomainSchema.shape.slug.optional()
-}).omit({ id: true });
-const updateBoardSchema = BoardDomainSchema.extend({
-  id: z.z.string()
-}).partial().required({ id: true });
+const createBoardSchema = z.z.object({
+  ...boardOperationFields,
+  slug: boardOperationFields.slug.optional()
+});
+const updateBoardSchema = z.z.object({ id: z.z.string(), ...boardOperationFields }).partial().required({ id: true });
 const columnDateFields = {
   createdAt: z.z.coerce.date().optional(),
   updatedAt: z.z.coerce.date().optional()
 };
 const columnCoreFields = {
   title: z.z.string().min(1, "Title is required"),
-  order: z.z.number().int().min(0).optional().default(0),
+  order: z.z.number().int().min(0).optional(),
   boardId: z.z.string().min(1, "Board ID is required")
 };
-const ColumnDomainSchema = z.z.object({
+z.z.object({
   id: z.z.string().optional(),
   ...columnCoreFields,
+  order: columnCoreFields.order.default(0),
   ...columnDateFields
 });
-const createColumnSchema = ColumnDomainSchema.omit({ id: true });
-const updateColumnSchema = ColumnDomainSchema.extend({
-  id: z.z.string()
-}).partial().required({ id: true });
+const createColumnSchema = z.z.object(columnCoreFields);
+const updateColumnSchema = z.z.object({ id: z.z.string(), ...columnCoreFields }).partial().required({ id: true });
 const taskDateFields = {
   completedAt: z.z.coerce.date().optional(),
   createdAt: z.z.coerce.date().optional(),
   updatedAt: z.z.coerce.date().optional()
 };
+const taskOperationCompletedAt = z.z.union([z.z.iso.datetime(), z.z.date()]).transform((value) => value instanceof Date ? value.toISOString() : value).optional();
 const taskCoreFields = {
   title: z.z.string().min(1, "Title is required"),
   description: z.z.string().optional(),
-  priority: PrioritySchema.optional().default("MEDIUM"),
-  order: z.z.number().int().min(0).optional().default(0),
+  priority: PrioritySchema.optional(),
+  order: z.z.number().int().min(0).optional(),
   columnId: z.z.string().min(1, "Column ID is required"),
   assigneeId: z.z.string().optional().nullable(),
-  isArchived: z.z.boolean().optional().default(false)
+  isArchived: z.z.boolean().optional()
 };
-const TaskDomainSchema = z.z.object({
+z.z.object({
   id: z.z.string().optional(),
   ...taskCoreFields,
+  priority: taskCoreFields.priority.default("MEDIUM"),
+  order: taskCoreFields.order.default(0),
+  isArchived: taskCoreFields.isArchived.default(false),
   ...taskDateFields
 });
-const createTaskSchema = TaskDomainSchema.omit({ id: true });
-const updateTaskSchema = TaskDomainSchema.extend({
-  id: z.z.string()
+const createTaskSchema = z.z.object({
+  ...taskCoreFields,
+  completedAt: taskOperationCompletedAt
+});
+const updateTaskSchema = z.z.object({
+  id: z.z.string(),
+  ...taskCoreFields,
+  completedAt: taskOperationCompletedAt
 }).partial().required({ id: true });
 const BoardListQuerySchema = z.z.object({
   slug: z.z.string().optional(),
@@ -101,11 +113,8 @@ const moveTaskSchema = z.z.object({
   targetOrder: z.z.number().int().min(0)
 });
 
-exports.BoardDomainSchema = BoardDomainSchema;
 exports.BoardListQuerySchema = BoardListQuerySchema;
-exports.ColumnDomainSchema = ColumnDomainSchema;
 exports.PrioritySchema = PrioritySchema;
-exports.TaskDomainSchema = TaskDomainSchema;
 exports.createBoardSchema = createBoardSchema;
 exports.createColumnSchema = createColumnSchema;
 exports.createTaskSchema = createTaskSchema;

package/dist/packages/stack/src/plugins/kanban/schemas.mjs

@@ -12,57 +12,69 @@ const boardCoreFields = {
   ownerId: z.string().optional(),
   organizationId: z.string().optional()
 };
-const BoardDomainSchema = z.object({
+const boardOperationFields = {
+  name: boardCoreFields.name,
+  slug: boardCoreFields.slug,
+  description: boardCoreFields.description
+};
+z.object({
   id: z.string().optional(),
   ...boardCoreFields,
   ...boardDateFields
 });
-const createBoardSchema = BoardDomainSchema.extend({
-  slug: BoardDomainSchema.shape.slug.optional()
-}).omit({ id: true });
-const updateBoardSchema = BoardDomainSchema.extend({
-  id: z.string()
-}).partial().required({ id: true });
+const createBoardSchema = z.object({
+  ...boardOperationFields,
+  slug: boardOperationFields.slug.optional()
+});
+const updateBoardSchema = z.object({ id: z.string(), ...boardOperationFields }).partial().required({ id: true });
 const columnDateFields = {
   createdAt: z.coerce.date().optional(),
   updatedAt: z.coerce.date().optional()
 };
 const columnCoreFields = {
   title: z.string().min(1, "Title is required"),
-  order: z.number().int().min(0).optional().default(0),
+  order: z.number().int().min(0).optional(),
   boardId: z.string().min(1, "Board ID is required")
 };
-const ColumnDomainSchema = z.object({
+z.object({
   id: z.string().optional(),
   ...columnCoreFields,
+  order: columnCoreFields.order.default(0),
   ...columnDateFields
 });
-const createColumnSchema = ColumnDomainSchema.omit({ id: true });
-const updateColumnSchema = ColumnDomainSchema.extend({
-  id: z.string()
-}).partial().required({ id: true });
+const createColumnSchema = z.object(columnCoreFields);
+const updateColumnSchema = z.object({ id: z.string(), ...columnCoreFields }).partial().required({ id: true });
 const taskDateFields = {
   completedAt: z.coerce.date().optional(),
   createdAt: z.coerce.date().optional(),
   updatedAt: z.coerce.date().optional()
 };
+const taskOperationCompletedAt = z.union([z.iso.datetime(), z.date()]).transform((value) => value instanceof Date ? value.toISOString() : value).optional();
 const taskCoreFields = {
   title: z.string().min(1, "Title is required"),
   description: z.string().optional(),
-  priority: PrioritySchema.optional().default("MEDIUM"),
-  order: z.number().int().min(0).optional().default(0),
+  priority: PrioritySchema.optional(),
+  order: z.number().int().min(0).optional(),
   columnId: z.string().min(1, "Column ID is required"),
   assigneeId: z.string().optional().nullable(),
-  isArchived: z.boolean().optional().default(false)
+  isArchived: z.boolean().optional()
 };
-const TaskDomainSchema = z.object({
+z.object({
   id: z.string().optional(),
   ...taskCoreFields,
+  priority: taskCoreFields.priority.default("MEDIUM"),
+  order: taskCoreFields.order.default(0),
+  isArchived: taskCoreFields.isArchived.default(false),
   ...taskDateFields
 });
-const createTaskSchema = TaskDomainSchema.omit({ id: true });
-const updateTaskSchema = TaskDomainSchema.extend({
-  id: z.string()
+const createTaskSchema = z.object({
+  ...taskCoreFields,
+  completedAt: taskOperationCompletedAt
+});
+const updateTaskSchema = z.object({
+  id: z.string(),
+  ...taskCoreFields,
+  completedAt: taskOperationCompletedAt
 }).partial().required({ id: true });
 const BoardListQuerySchema = z.object({
   slug: z.string().optional(),
@@ -99,4 +111,4 @@ const moveTaskSchema = z.object({
   targetOrder: z.number().int().min(0)
 });
 
-export { BoardDomainSchema, BoardListQuerySchema, ColumnDomainSchema, PrioritySchema, TaskDomainSchema, createBoardSchema, createColumnSchema, createTaskSchema, moveTaskSchema, reorderColumnsSchema, reorderTasksSchema, updateBoardSchema, updateColumnSchema, updateTaskSchema };
+export { BoardListQuerySchema, PrioritySchema, createBoardSchema, createColumnSchema, createTaskSchema, moveTaskSchema, reorderColumnsSchema, reorderTasksSchema, updateBoardSchema, updateColumnSchema, updateTaskSchema };

package/dist/packages/stack/src/plugins/media/api/lifecycle-migrations.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+const MEDIA_LIFECYCLE_HOOK_MIGRATIONS = Object.freeze({
+  onBeforeDelete: "onBeforeDeleteAsset",
+  onAfterDelete: "onAfterDeleteAsset",
+  onOperationError: "onError"
+});
+
+exports.MEDIA_LIFECYCLE_HOOK_MIGRATIONS = MEDIA_LIFECYCLE_HOOK_MIGRATIONS;

package/dist/packages/stack/src/plugins/media/api/lifecycle-migrations.mjs

@@ -0,0 +1,7 @@
+const MEDIA_LIFECYCLE_HOOK_MIGRATIONS = Object.freeze({
+  onBeforeDelete: "onBeforeDeleteAsset",
+  onAfterDelete: "onAfterDeleteAsset",
+  onOperationError: "onError"
+});
+
+export { MEDIA_LIFECYCLE_HOOK_MIGRATIONS };

package/dist/packages/stack/src/plugins/media/api/mutations.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 async function createAsset(adapter, input) {
+  const now = /* @__PURE__ */ new Date();
   return adapter.create({
     model: "mediaAsset",
     data: {
@@ -12,7 +13,8 @@ async function createAsset(adapter, input) {
       folderId: input.folderId,
       alt: input.alt,
       tenantId: input.tenantId,
-      createdAt: /* @__PURE__ */ new Date()
+      createdAt: now,
+      updatedAt: now
     }
   });
 }
@@ -24,6 +26,7 @@ async function updateAsset(adapter, id, input) {
   if ("folderId" in input) {
     update.folderId = input.folderId;
   }
+  update.updatedAt = /* @__PURE__ */ new Date();
   return adapter.update({
     model: "mediaAsset",
     where: [{ field: "id", value: id, operator: "eq" }],
@@ -37,13 +40,15 @@ async function deleteAsset(adapter, id) {
   });
 }
 async function createFolder(adapter, input) {
+  const now = /* @__PURE__ */ new Date();
   return adapter.create({
     model: "mediaFolder",
     data: {
       name: input.name,
       parentId: input.parentId,
       tenantId: input.tenantId,
-      createdAt: /* @__PURE__ */ new Date()
+      createdAt: now,
+      updatedAt: now
     }
   });
 }