nextjs-cms 0.9.36 → 0.9.37

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

@@ -1,194 +0,0 @@
-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/routers/hasItemsSection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hasItemsSection.d.ts","sourceRoot":"","sources":["../../../src/api/routers/hasItemsSection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAcxB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAwG+53C,CAAC;;;;;uBAAyE,CAAC;;;;;;uBAA8G,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GADzn4C,CAAA"}

package/dist/api/routers/hasItemsSection.js

@@ -1,86 +0,0 @@
-import { privateProcedure, router } from '../trpc.js';
-import * as z from 'zod';
-import { createEditPage, createNewPage, deleteLocaleTranslation, deleteSectionItem, getBrowsePage, } from '../lib/serverActions.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/routers/logs.d.ts

@@ -1,59 +0,0 @@
-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/routers/logs.d.ts.map

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

package/dist/api/routers/logs.js

@@ -1,76 +0,0 @@
-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 '../lib/serverActions.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,
-        };
-    }),
-});