nextjs-cms 0.9.37 → 0.9.39

package/dist/api/trpc/root.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"root.d.ts","sourceRoot":"","sources":["../../../src/api/trpc/root.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAsBvB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAiBqxe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAA+1nB,CAAC;;;;;2BAA0E,CAAC;;;;;;2BAAgH,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAAt4/B,CAAC;;;;;2BAAuE,CAAC;;;;;;2BAA6G,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAH1nH,CAAA;AAED,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAA"}
+{"version":3,"file":"root.d.ts","sourceRoot":"","sources":["../../../src/api/trpc/root.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAsBvB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAiBw8d,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAA+0mB,CAAC;;;;;2BAAyE,CAAC;;;;;;2BAA8G,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAA7o+B,CAAC;;;;;2BAAsE,CAAC;;;;;;2BAA2G,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAHhhH,CAAA;AAED,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAA"}

package/dist/api/trpc/routers/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../src/api/trpc/routers/config.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAaknhB,CAAC;;;;;;GAD1ohB,CAAA"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../src/api/trpc/routers/config.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAagvgB,CAAC;;;;;;GADxwgB,CAAA"}

package/dist/api/trpc/routers/hasItemsSection.d.ts

@@ -26,12 +26,14 @@ export declare const hasItemsSectionRouter: import("@trpc/server").TRPCBuiltRout
             sectionName: string;
             page?: number | undefined;
             q?: string | undefined;
+            locale?: string | undefined;
         };
         output: {
             error: {
                 message: string;
             };
             section?: undefined;
+            localization?: undefined;
             items?: undefined;
             totalCount?: undefined;
         } | {
@@ -40,6 +42,24 @@ export declare const hasItemsSectionRouter: import("@trpc/server").TRPCBuiltRout
                 name: string;
                 title: string;
             };
+            localization: {
+                locales: {
+                    code: string;
+                    label: string;
+                    rtl?: boolean;
+                }[];
+                defaultLocale: {
+                    code: string;
+                    label: string;
+                    rtl?: boolean;
+                };
+                currentLocale: {
+                    code: string;
+                    label: string;
+                    rtl?: boolean;
+                };
+                localeSwitcherEnabled: boolean;
+            } | null;
             items: (Record<string, any> | {
                 id: string | number;
                 headingTitle: string;
@@ -47,6 +67,7 @@ export declare const hasItemsSectionRouter: import("@trpc/server").TRPCBuiltRout
                 createdAt: string;
                 createdBy: string;
                 permission: number;
+                locales: string[];
             })[];
             totalCount: any;
             error?: undefined;
@@ -86,7 +107,7 @@ export declare const hasItemsSectionRouter: import("@trpc/server").TRPCBuiltRout
                     label: string;
                     required: boolean;
                     localized?: boolean;
-                    conditionalFields: import("../../../core/types/index.js").ConditionalField[];
+                    conditionalGroup?: import("../../../core/types/index.js").ConditionalGroupClient;
                     readonly: boolean;
                     defaultValue: any;
                     value: any;
@@ -129,7 +150,7 @@ export declare const hasItemsSectionRouter: import("@trpc/server").TRPCBuiltRout
                     label: string;
                     required: boolean;
                     localized?: boolean;
-                    conditionalFields: import("../../../core/types/index.js").ConditionalField[];
+                    conditionalGroup?: import("../../../core/types/index.js").ConditionalGroupClient;
                     readonly: boolean;
                     defaultValue: any;
                     value: any;

package/dist/api/trpc/routers/hasItemsSection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hasItemsSection.d.ts","sourceRoot":"","sources":["../../../../src/api/trpc/routers/hasItemsSection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAcxB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAwGq1hC,CAAC;;;;;uBAA0E,CAAC;;;;;;uBAAgH,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GADljiC,CAAA"}
+{"version":3,"file":"hasItemsSection.d.ts","sourceRoot":"","sources":["../../../../src/api/trpc/routers/hasItemsSection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAcxB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAyGs4/B,CAAC;;;;;uBAAyE,CAAC;;;;;;uBAA8G,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GADhmgC,CAAA"}

package/dist/api/trpc/routers/hasItemsSection.js

@@ -12,9 +12,10 @@ export const hasItemsSectionRouter = router({
         sectionName: z.string(),
         page: z.number().optional(),
         q: z.string().optional(),
+        locale: z.string().optional(),
     }))
         .query(async ({ ctx, input }) => {
-        return await getBrowsePage(ctx.session, input.sectionName, input.page, input.q);
+        return await getBrowsePage(ctx.session, input.sectionName, input.page, input.q, input.locale);
     }),
     newItem: privateProcedure
         .input(z.object({

package/dist/api/trpc/routers/logs.d.ts

@@ -24,7 +24,10 @@ export declare const logsRouter: import("@trpc/server").TRPCBuiltRouter<{
     list: import("@trpc/server").TRPCQueryProcedure<{
         input: {
             limit?: number | undefined;
-            offset?: number | undefined;
+            cursor?: {
+                createdAt: unknown;
+                id: number;
+            } | null | undefined;
             eventType?: string | undefined;
             actorId?: string | undefined;
             sectionName?: string | undefined;
@@ -35,6 +38,7 @@ export declare const logsRouter: import("@trpc/server").TRPCBuiltRouter<{
         } | undefined;
         output: {
             items: {
+                actorDeleted: boolean;
                 id: number;
                 eventType: string;
                 actorId: string | null;
@@ -48,10 +52,39 @@ export declare const logsRouter: import("@trpc/server").TRPCBuiltRouter<{
                 userAgent: string | null;
                 source: string | null;
                 createdAt: Date;
+                actorCurrentFullName: string | null;
+            }[];
+            nextCursor: {
+                createdAt: Date;
+                id: number;
+            } | null;
+        };
+        meta: object;
+    }>;
+    recent: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            limit?: number | undefined;
+        } | undefined;
+        output: {
+            id: number;
+            eventType: string;
+            actorId: string | null;
+            actorUsername: string | null;
+            entityLabel: string | null;
+            sectionName: string | null;
+            createdAt: Date;
+        }[];
+        meta: object;
+    }>;
+    filterOptions: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            eventTypes: string[];
+            sections: string[];
+            actors: {
+                id: string;
+                username: string;
             }[];
-            total: number;
-            limit: number;
-            offset: number;
         };
         meta: object;
     }>;

package/dist/api/trpc/routers/logs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logs.d.ts","sourceRoot":"","sources":["../../../../src/api/trpc/routers/logs.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAqBxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiErB,CAAA"}
+{"version":3,"file":"logs.d.ts","sourceRoot":"","sources":["../../../../src/api/trpc/routers/logs.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAkCxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAqG8B,MAAM;0BAAY,MAAM;;;;;GAG3E,CAAA"}

package/dist/api/trpc/routers/logs.js

@@ -1,15 +1,19 @@
 import { TRPCError } from '@trpc/server';
-import { and, desc, eq, gte, lte, sql } from 'drizzle-orm';
+import { and, desc, eq, gte, lt, lte, or } from 'drizzle-orm';
 import * as z from 'zod';
 import { db } from '../../../db/client.js';
-import { LogsTable } from '../../../db/schema.js';
+import { AdminsTable, LogsTable } from '../../../db/schema.js';
+import getString from '../../../translations/index.js';
 import { isAccessAllowed } from '../../actions/privileges.js';
 import { privateProcedure, router } from '../trpc.js';
-import getString from '../../../translations/index.js';
+const cursorSchema = z.object({
+    createdAt: z.coerce.date(),
+    id: z.number(),
+});
 const listInputSchema = z
     .object({
     limit: z.number().min(1).max(200).optional(),
-    offset: z.number().min(0).optional(),
+    cursor: cursorSchema.nullish(),
     eventType: z.string().optional(),
     actorId: z.string().optional(),
     sectionName: z.string().optional(),
@@ -19,61 +23,106 @@ const listInputSchema = z
     to: z.string().datetime().optional(),
 })
     .optional();
+const ensureAccess = async (userId, language) => {
+    const accessAllowed = await isAccessAllowed({ sectionName: 'log', userId });
+    if (!accessAllowed) {
+        throw new TRPCError({ code: 'NOT_FOUND', message: getString('sectionNotFound', language) });
+    }
+};
 export const logsRouter = router({
     list: privateProcedure.input(listInputSchema).query(async ({ ctx, input }) => {
-        const accessAllowed = await isAccessAllowed({
-            sectionName: 'log',
-            userId: ctx.session.user.id,
-        });
-        if (!accessAllowed) {
-            throw new TRPCError({
-                code: 'NOT_FOUND',
-                message: getString('sectionNotFound', ctx.session.user.language),
-            });
-        }
+        await ensureAccess(ctx.session.user.id, ctx.session.user.language);
         const limit = input?.limit ?? 50;
-        const offset = input?.offset ?? 0;
         const conditions = [];
-        if (input?.eventType) {
+        if (input?.eventType)
             conditions.push(eq(LogsTable.eventType, input.eventType));
-        }
-        if (input?.actorId) {
+        if (input?.actorId)
             conditions.push(eq(LogsTable.actorId, input.actorId));
-        }
-        if (input?.sectionName) {
+        if (input?.sectionName)
             conditions.push(eq(LogsTable.sectionName, input.sectionName));
-        }
-        if (input?.entityType) {
+        if (input?.entityType)
             conditions.push(eq(LogsTable.entityType, input.entityType));
-        }
-        if (input?.entityId) {
+        if (input?.entityId)
             conditions.push(eq(LogsTable.entityId, input.entityId));
-        }
-        if (input?.from) {
+        if (input?.from)
             conditions.push(gte(LogsTable.createdAt, new Date(input.from)));
-        }
-        if (input?.to) {
+        if (input?.to)
             conditions.push(lte(LogsTable.createdAt, new Date(input.to)));
+        // Keyset pagination on (createdAt, id) descending.
+        if (input?.cursor) {
+            const { createdAt, id } = input.cursor;
+            conditions.push(or(lt(LogsTable.createdAt, createdAt), and(eq(LogsTable.createdAt, createdAt), lt(LogsTable.id, id))));
         }
         const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
-        let listQuery = db.select().from(LogsTable).$dynamic();
-        let countQuery = db
-            .select({ count: sql `count(*)` })
+        const rows = await db
+            .select({
+            id: LogsTable.id,
+            eventType: LogsTable.eventType,
+            actorId: LogsTable.actorId,
+            actorUsername: LogsTable.actorUsername,
+            entityType: LogsTable.entityType,
+            entityId: LogsTable.entityId,
+            entityLabel: LogsTable.entityLabel,
+            sectionName: LogsTable.sectionName,
+            metadata: LogsTable.metadata,
+            ipAddress: LogsTable.ipAddress,
+            userAgent: LogsTable.userAgent,
+            source: LogsTable.source,
+            createdAt: LogsTable.createdAt,
+            actorCurrentFullName: AdminsTable.fullName,
+            actorCurrentId: AdminsTable.id,
+        })
             .from(LogsTable)
-            .$dynamic();
-        if (whereClause) {
-            listQuery = listQuery.where(whereClause);
-            countQuery = countQuery.where(whereClause);
-        }
-        const [rows, totalRows] = await Promise.all([
-            listQuery.orderBy(desc(LogsTable.createdAt)).limit(limit).offset(offset),
-            countQuery,
+            .leftJoin(AdminsTable, eq(AdminsTable.id, LogsTable.actorId))
+            .where(whereClause)
+            .orderBy(desc(LogsTable.createdAt), desc(LogsTable.id))
+            .limit(limit + 1);
+        const hasMore = rows.length > limit;
+        const items = (hasMore ? rows.slice(0, limit) : rows).map((row) => {
+            const { actorCurrentId, ...rest } = row;
+            return {
+                ...rest,
+                // A log can have a null actorId (system events). Only call it "deleted"
+                // when it referenced an actor that no longer resolves to an admin.
+                actorDeleted: rest.actorId != null && actorCurrentId == null,
+            };
+        });
+        const last = items[items.length - 1];
+        const nextCursor = hasMore && last ? { createdAt: last.createdAt, id: last.id } : null;
+        return { items, nextCursor };
+    }),
+    // Minimal recent-activity feed for the navbar notifications popup.
+    // Intentionally NOT gated by the 'log' privilege: available to any authenticated
+    // admin. Returns only the few, low-sensitivity fields the popup renders.
+    recent: privateProcedure
+        .input(z.object({ limit: z.number().min(1).max(50).optional() }).optional())
+        .query(async ({ input }) => {
+        const limit = input?.limit ?? 20;
+        return db
+            .select({
+            id: LogsTable.id,
+            eventType: LogsTable.eventType,
+            actorId: LogsTable.actorId,
+            actorUsername: LogsTable.actorUsername,
+            entityLabel: LogsTable.entityLabel,
+            sectionName: LogsTable.sectionName,
+            createdAt: LogsTable.createdAt,
+        })
+            .from(LogsTable)
+            .orderBy(desc(LogsTable.createdAt), desc(LogsTable.id))
+            .limit(limit);
+    }),
+    filterOptions: privateProcedure.query(async ({ ctx }) => {
+        await ensureAccess(ctx.session.user.id, ctx.session.user.language);
+        const [eventTypeRows, sectionRows, actorRows] = await Promise.all([
+            db.selectDistinct({ value: LogsTable.eventType }).from(LogsTable),
+            db.selectDistinct({ value: LogsTable.sectionName }).from(LogsTable),
+            db.selectDistinct({ id: LogsTable.actorId, username: LogsTable.actorUsername }).from(LogsTable),
         ]);
         return {
-            items: rows,
-            total: totalRows[0]?.count ?? 0,
-            limit,
-            offset,
+            eventTypes: eventTypeRows.map((r) => r.value).filter((v) => v != null),
+            sections: sectionRows.map((r) => r.value).filter((v) => v != null),
+            actors: actorRows.filter((r) => r.id != null && r.username != null),
         };
     }),
 });