nextjs-cms 0.9.22 → 0.9.24

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

@@ -0,0 +1,194 @@
+import * as z from 'zod';
+export declare const hasItemsSectionRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: {
+        headers: Headers;
+        db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../../../db/schema.js")> & {
+            $client: import("mysql2/promise").Pool;
+        };
+        session: import("../../../index.js").Session | null;
+    };
+    meta: object;
+    errorShape: {
+        data: {
+            zodError: z.core.$ZodFlattenedError<unknown, string> | null;
+            code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+        };
+        message: string;
+        code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: true;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    listItems: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            sectionName: string;
+            page?: number | undefined;
+            q?: string | undefined;
+        };
+        output: {
+            error: {
+                message: string;
+            };
+            section?: undefined;
+            items?: undefined;
+            totalCount?: undefined;
+        } | {
+            section: {
+                hasSearch: boolean;
+                name: string;
+                title: string;
+            };
+            items: (Record<string, any> | {
+                id: string | number;
+                headingTitle: string;
+                coverPhoto: string | null;
+                createdAt: string;
+                createdBy: string;
+                permission: number;
+            })[];
+            totalCount: any;
+            error?: undefined;
+        };
+        meta: object;
+    }>;
+    newItem: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            sectionName: string;
+        };
+        output: {
+            error: {
+                message: any;
+            };
+            section?: undefined;
+            inputGroups?: undefined;
+            defaultLocale?: undefined;
+        } | {
+            section: {
+                name: string;
+                title: {
+                    section: string;
+                    singular: string;
+                    plural: string;
+                };
+                gallery: import("../../../index.js").SectionGallery | undefined;
+                variants: import("../../../core/types/index.js").Variant[] | undefined;
+                configFile: string;
+            };
+            inputGroups: {
+                groupId: number;
+                groupTitle: string;
+                groupOrder: number;
+                inputs: {
+                    type: import("../../../core/types/index.js").FieldType;
+                    name: string;
+                    label: string;
+                    required: boolean;
+                    localized?: boolean;
+                    conditionalFields: import("../../../core/types/index.js").ConditionalField[];
+                    readonly: boolean;
+                    defaultValue: any;
+                    value: any;
+                }[];
+            }[] | undefined;
+            defaultLocale: {
+                code: string;
+                label: string;
+                rtl?: boolean;
+            } | null;
+            error?: undefined;
+        };
+        meta: object;
+    }>;
+    editItem: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            sectionName: string;
+            sectionItemId: string | number;
+            locale?: string | undefined;
+        };
+        output: {
+            section: {
+                name: string;
+                title: {
+                    section: string;
+                    singular: string;
+                    plural: string;
+                };
+                gallery: import("../../../index.js").SectionGallery | undefined;
+                variants: import("../../../core/types/index.js").Variant[] | undefined;
+                configFile: string;
+            };
+            inputGroups: {
+                groupId: number;
+                groupTitle: string;
+                groupOrder: number;
+                inputs: {
+                    type: import("../../../core/types/index.js").FieldType;
+                    name: string;
+                    label: string;
+                    required: boolean;
+                    localized?: boolean;
+                    conditionalFields: import("../../../core/types/index.js").ConditionalField[];
+                    readonly: boolean;
+                    defaultValue: any;
+                    value: any;
+                }[];
+            }[] | undefined;
+            gallery: {
+                referenceId: string;
+                photo: string;
+                meta: any;
+                locale?: string;
+            }[];
+            localization: {
+                defaultLocale: {
+                    code: string;
+                    label: string;
+                    rtl?: boolean;
+                };
+                currentLocale: {
+                    code: string;
+                    label: string;
+                    rtl?: boolean;
+                };
+                existingTranslations: string[];
+                locales: {
+                    code: string;
+                    label: string;
+                    rtl?: boolean;
+                }[];
+                localeSwitcherEnabled: boolean;
+                developerNoteEnabled: boolean;
+            } | null;
+            error?: undefined;
+        } | {
+            error: {
+                message: any;
+            };
+            section?: undefined;
+            inputGroups?: undefined;
+            gallery?: undefined;
+            localization?: undefined;
+        };
+        meta: object;
+    }>;
+    deleteItem: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            sectionName: string;
+            sectionItemId: string | number;
+        };
+        output: boolean;
+        meta: object;
+    }>;
+    deleteLocaleTranslation: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            sectionName: string;
+            sectionItemId: string | number;
+            locale: string;
+        };
+        output: boolean;
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=hasItemsSection.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,86 @@
+import { privateProcedure, router } from '../trpc.js';
+import * as z from 'zod';
+import { createEditPage, createNewPage, deleteLocaleTranslation, deleteSectionItem, getBrowsePage, } from '../../actions/pages.js';
+import { getRequestMetadataFromHeaders } from '../../../logging/index.js';
+import { TRPCError } from '@trpc/server';
+import { getCMSConfig } from '../../../core/config/index.js';
+import { resolveLocale } from '../../../core/localization/index.js';
+import getString from '../../../translations/index.js';
+export const hasItemsSectionRouter = router({
+    listItems: privateProcedure
+        .input(z.object({
+        sectionName: z.string(),
+        page: z.number().optional(),
+        q: z.string().optional(),
+    }))
+        .query(async ({ ctx, input }) => {
+        return await getBrowsePage(ctx.session, input.sectionName, input.page, input.q);
+    }),
+    newItem: privateProcedure
+        .input(z.object({
+        sectionName: z.string(),
+    }))
+        .query(async ({ ctx, input }) => {
+        return await createNewPage(ctx.session, input.sectionName);
+    }),
+    editItem: privateProcedure
+        .input(z.object({
+        sectionName: z.string(),
+        sectionItemId: z.number().or(z.string()),
+        locale: z.string().optional(),
+    }))
+        .query(async ({ ctx, input }) => {
+        return await createEditPage(ctx.session, input.sectionName, input.sectionItemId, input.locale);
+    }),
+    deleteItem: privateProcedure
+        .input(z.object({ sectionName: z.string(), sectionItemId: z.number().or(z.string()) }))
+        .mutation(async ({ ctx, input }) => {
+        const requestMetadata = getRequestMetadataFromHeaders(ctx.headers);
+        const result = await deleteSectionItem(ctx.session, input.sectionName, input.sectionItemId, undefined, requestMetadata);
+        if (result && typeof result === 'object' && 'error' in result) {
+            const message = result.error?.message ?? 'Failed to delete section item';
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message,
+            });
+        }
+        return result;
+    }),
+    deleteLocaleTranslation: privateProcedure
+        .input(z.object({
+        sectionName: z.string(),
+        sectionItemId: z.number().or(z.string()),
+        locale: z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const cmsConfig = await getCMSConfig();
+        const localeResult = resolveLocale({
+            localization: cmsConfig.localization,
+            locale: input.locale,
+        });
+        if (!localeResult.resolvedLocale) {
+            if (localeResult.localizationEnabled === false) {
+                throw new TRPCError({
+                    code: 'BAD_REQUEST',
+                    message: getString('localizationNotEnabledForSection', ctx.session.user.language),
+                });
+            }
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: getString('invalidLocale', ctx.session.user.language, {
+                    locale: input.locale,
+                    locales: localeResult.availableLocales.map((l) => l.code).join(', '),
+                }),
+            });
+        }
+        const result = await deleteLocaleTranslation(ctx.session, input.sectionName, input.sectionItemId, localeResult.resolvedLocale.code);
+        if (result && typeof result === 'object' && 'error' in result) {
+            const message = result.error?.message ?? 'Failed to delete locale translation';
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message,
+            });
+        }
+        return result;
+    }),
+});

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

@@ -0,0 +1,59 @@
+import * as z from 'zod';
+export declare const logsRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: {
+        headers: Headers;
+        db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../../../db/schema.js")> & {
+            $client: import("mysql2/promise").Pool;
+        };
+        session: import("../../../index.js").Session | null;
+    };
+    meta: object;
+    errorShape: {
+        data: {
+            zodError: z.core.$ZodFlattenedError<unknown, string> | null;
+            code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+        };
+        message: string;
+        code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: true;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    list: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            limit?: number | undefined;
+            offset?: number | undefined;
+            eventType?: string | undefined;
+            actorId?: string | undefined;
+            sectionName?: string | undefined;
+            entityType?: string | undefined;
+            entityId?: string | undefined;
+            from?: string | undefined;
+            to?: string | undefined;
+        } | undefined;
+        output: {
+            items: {
+                id: number;
+                eventType: string;
+                actorId: string | null;
+                actorUsername: string | null;
+                entityType: string | null;
+                entityId: string | null;
+                entityLabel: string | null;
+                sectionName: string | null;
+                metadata: string | null;
+                ipAddress: string | null;
+                userAgent: string | null;
+                source: string | null;
+                createdAt: Date;
+            }[];
+            total: number;
+            limit: number;
+            offset: number;
+        };
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=logs.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,79 @@
+import { TRPCError } from '@trpc/server';
+import { and, desc, eq, gte, lte, sql } from 'drizzle-orm';
+import * as z from 'zod';
+import { db } from '../../../db/client.js';
+import { LogsTable } from '../../../db/schema.js';
+import { isAccessAllowed } from '../../actions/privileges.js';
+import { privateProcedure, router } from '../trpc.js';
+import getString from '../../../translations/index.js';
+const listInputSchema = z
+    .object({
+    limit: z.number().min(1).max(200).optional(),
+    offset: z.number().min(0).optional(),
+    eventType: z.string().optional(),
+    actorId: z.string().optional(),
+    sectionName: z.string().optional(),
+    entityType: z.string().optional(),
+    entityId: z.string().optional(),
+    from: z.string().datetime().optional(),
+    to: z.string().datetime().optional(),
+})
+    .optional();
+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),
+            });
+        }
+        const limit = input?.limit ?? 50;
+        const offset = input?.offset ?? 0;
+        const conditions = [];
+        if (input?.eventType) {
+            conditions.push(eq(LogsTable.eventType, input.eventType));
+        }
+        if (input?.actorId) {
+            conditions.push(eq(LogsTable.actorId, input.actorId));
+        }
+        if (input?.sectionName) {
+            conditions.push(eq(LogsTable.sectionName, input.sectionName));
+        }
+        if (input?.entityType) {
+            conditions.push(eq(LogsTable.entityType, input.entityType));
+        }
+        if (input?.entityId) {
+            conditions.push(eq(LogsTable.entityId, input.entityId));
+        }
+        if (input?.from) {
+            conditions.push(gte(LogsTable.createdAt, new Date(input.from)));
+        }
+        if (input?.to) {
+            conditions.push(lte(LogsTable.createdAt, new Date(input.to)));
+        }
+        const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
+        let listQuery = db.select().from(LogsTable).$dynamic();
+        let countQuery = db
+            .select({ count: sql `count(*)` })
+            .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,
+        ]);
+        return {
+            items: rows,
+            total: totalRows[0]?.count ?? 0,
+            limit,
+            offset,
+        };
+    }),
+});