@mohasinac/appkit 2.4.11 → 2.5.0

package/dist/_internal/server/jobs/runtime/adapters/firebase.js

@@ -0,0 +1,156 @@
+/**
+ * Firebase runtime adapter for appkit job handlers.
+ *
+ * Wraps pure handler functions into Firebase Functions v2 triggers so the
+ * consumer's `functions/src/index.ts` becomes a thin barrel:
+ *
+ *   import { handlers } from "./_internal/server/jobs/handlers";
+ *   export const auctionSettlement = bindSchedule("auctionSettlement", handlers.auctionSettlement, { schedule: "every 15 minutes" });
+ *
+ * The adapter resolves a JobContext (db + logger + env) per invocation so the
+ * handler stays portable.
+ */
+import { onSchedule } from "firebase-functions/v2/scheduler";
+import { onDocumentWritten, onDocumentCreated, onDocumentUpdated, } from "firebase-functions/v2/firestore";
+import { onCall, onRequest, } from "firebase-functions/v2/https";
+import { getAdminDb } from "../../../../../providers/db-firebase";
+import { serverLogger } from "../../../../../monitoring";
+function buildContext(job) {
+    const logger = {
+        info: (msg, meta) => serverLogger.info(`[${job}] ${msg}`, meta),
+        warn: (msg, meta) => serverLogger.warn(`[${job}] ${msg}`, meta),
+        error: (msg, err, meta) => serverLogger.error(`[${job}] ${msg}`, { err, ...(meta ?? {}) }),
+    };
+    return {
+        job,
+        db: getAdminDb(),
+        logger,
+        env: (key) => process.env[key],
+        now: new Date(),
+    };
+}
+export function bindSchedule(job, handler, options) {
+    return onSchedule(options, async () => {
+        const ctx = buildContext(job);
+        try {
+            await handler(ctx);
+        }
+        catch (err) {
+            ctx.logger.error("Fatal error during scheduled job", err);
+            throw err;
+        }
+    });
+}
+export function bindDocumentWritten(job, handler, options) {
+    return onDocumentWritten(options, async (event) => {
+        const ctx = buildContext(job);
+        const before = (event.data?.before?.exists ? event.data?.before?.data() : null) ?? null;
+        const after = (event.data?.after?.exists ? event.data?.after?.data() : null) ?? null;
+        try {
+            await handler({
+                path: (event.data?.after?.ref ?? event.data?.before?.ref)?.path ?? "",
+                params: event.params,
+                before,
+                after,
+            }, ctx);
+        }
+        catch (err) {
+            ctx.logger.error("Fatal error during document write trigger", err);
+            throw err;
+        }
+    });
+}
+export function bindDocumentCreated(job, handler, options) {
+    return onDocumentCreated(options, async (event) => {
+        const ctx = buildContext(job);
+        const after = (event.data?.exists ? event.data?.data() : null) ?? null;
+        try {
+            await handler({
+                path: event.data?.ref.path ?? "",
+                params: event.params,
+                before: null,
+                after,
+            }, ctx);
+        }
+        catch (err) {
+            ctx.logger.error("Fatal error during document create trigger", err);
+            throw err;
+        }
+    });
+}
+export function bindDocumentUpdated(job, handler, options) {
+    return onDocumentUpdated(options, async (event) => {
+        const ctx = buildContext(job);
+        const before = (event.data?.before?.exists ? event.data?.before?.data() : null) ?? null;
+        const after = (event.data?.after?.exists ? event.data?.after?.data() : null) ?? null;
+        try {
+            await handler({
+                path: event.data?.after?.ref.path ?? event.data?.before?.ref.path ?? "",
+                params: event.params,
+                before,
+                after,
+            }, ctx);
+        }
+        catch (err) {
+            ctx.logger.error("Fatal error during document update trigger", err);
+            throw err;
+        }
+    });
+}
+export function bindCallable(job, handler, options) {
+    return onCall(options, async (request) => {
+        const ctx = buildContext(job);
+        try {
+            return await handler(request.data, ctx);
+        }
+        catch (err) {
+            ctx.logger.error("Fatal error during callable", err);
+            throw err;
+        }
+    });
+}
+/**
+ * Bind a pure callable handler to a Firebase HTTPS Cloud Function with
+ * shared-secret authentication. Translates JSON body → handler input and
+ * handler output → JSON response. Status codes:
+ *  - 401 if secret invalid
+ *  - 405 if method not allowed
+ *  - 400 if handler throws a ValidationError-shaped error
+ *  - 500 on any other thrown error
+ */
+export function bindHttps(job, handler, options) {
+    const { secretEnvVar, methods = ["POST"], ...httpsOptions } = options;
+    return onRequest(httpsOptions, async (req, res) => {
+        const ctx = buildContext(job);
+        if (secretEnvVar) {
+            const expected = process.env[secretEnvVar];
+            const header = req.headers["x-internal-secret"];
+            const provided = Array.isArray(header) ? header[0] : header;
+            if (!expected || provided !== expected) {
+                res.status(401).json({ error: "Unauthorized" });
+                return;
+            }
+        }
+        if (!methods.includes(req.method)) {
+            res.status(405).json({ error: "Method not allowed" });
+            return;
+        }
+        try {
+            const output = await handler(req.body, ctx);
+            res.status(200).json(output);
+        }
+        catch (err) {
+            const status = err?.httpStatus ?? 500;
+            ctx.logger.error("HTTPS handler error", err);
+            res.status(status).json({ error: err instanceof Error ? err.message : "Internal error" });
+        }
+    });
+}
+export const bindToFirebase = {
+    schedule: bindSchedule,
+    documentWritten: bindDocumentWritten,
+    documentCreated: bindDocumentCreated,
+    documentUpdated: bindDocumentUpdated,
+    callable: bindCallable,
+    https: bindHttps,
+};

package/dist/_internal/server/jobs/runtime/types.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Job runtime contracts for appkit-owned handlers.
+ *
+ * Handlers live in `appkit/src/_internal/server/jobs/handlers/<name>.ts` as
+ * pure async functions. A runtime adapter (e.g. `bindToFirebase`) wraps them
+ * with provider-specific triggers (Cloud Scheduler, Firestore onWrite, etc.)
+ * inside the consumer's `functions/src/index.ts`.
+ *
+ * The boundaries below intentionally keep the handler ignorant of which
+ * provider it runs under. The adapter is responsible for translating
+ * Firebase-specific events into JobContext + payloads.
+ */
+import type { Firestore } from "firebase-admin/firestore";
+export interface JobLogger {
+    info(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+    error(message: string, err?: unknown, meta?: Record<string, unknown>): void;
+}
+export interface JobContext {
+    /** Stable job/trigger name for log correlation. */
+    job: string;
+    /** Resolved firebase-admin Firestore instance. */
+    db: Firestore;
+    /** Logger bound to the job name. */
+    logger: JobLogger;
+    /** Process env at runtime (lookup function so tests can stub easily). */
+    env: (key: string) => string | undefined;
+    /** Current UTC time at invocation. */
+    now: Date;
+}
+/** Scheduled job — no payload, returns void. */
+export type ScheduleHandler = (ctx: JobContext) => Promise<void>;
+/** Firestore document trigger — receives the doc snapshot delta. */
+export interface FirestoreTriggerEvent<TBefore = unknown, TAfter = unknown> {
+    /** The Firestore document path including segment values. */
+    path: string;
+    /** Path params extracted from the wildcard pattern. */
+    params: Record<string, string>;
+    /** Document state before the write (null on create). */
+    before: TBefore | null;
+    /** Document state after the write (null on delete). */
+    after: TAfter | null;
+}
+export type FirestoreTriggerHandler<TBefore = unknown, TAfter = unknown> = (event: FirestoreTriggerEvent<TBefore, TAfter>, ctx: JobContext) => Promise<void>;
+/** Callable / HTTPS handler — opaque input/output. */
+export type CallableHandler<TInput = unknown, TOutput = unknown> = (input: TInput, ctx: JobContext) => Promise<TOutput>;
+/** Bundle of handlers a consumer wires into Firebase (or another runtime). */
+export interface JobHandlers {
+    schedules?: Record<string, ScheduleHandler>;
+    triggers?: Record<string, FirestoreTriggerHandler>;
+    callables?: Record<string, CallableHandler>;
+}

package/dist/_internal/server/jobs/runtime/types.js

@@ -0,0 +1,13 @@
+/**
+ * Job runtime contracts for appkit-owned handlers.
+ *
+ * Handlers live in `appkit/src/_internal/server/jobs/handlers/<name>.ts` as
+ * pure async functions. A runtime adapter (e.g. `bindToFirebase`) wraps them
+ * with provider-specific triggers (Cloud Scheduler, Firestore onWrite, etc.)
+ * inside the consumer's `functions/src/index.ts`.
+ *
+ * The boundaries below intentionally keep the handler ignorant of which
+ * provider it runs under. The adapter is responsible for translating
+ * Firebase-specific events into JobContext + payloads.
+ */
+export {};

package/dist/_internal/shared/config/index.d.ts

@@ -0,0 +1 @@
+export type { AppkitConfig, AppkitSmokeRoute, AppkitThemeProbeRoute, AppkitAuthFixture } from "./schema";

package/dist/_internal/shared/config/index.js

@@ -0,0 +1 @@
+export {};

package/dist/_internal/shared/config/schema.d.ts

@@ -0,0 +1,82 @@
+/**
+ * AppkitConfig — consumer's contract with all appkit CLI binaries.
+ *
+ * Place an `appkit.config.ts` (or .js / .mjs) at the root of your project.
+ * All CLI binaries discover it via `process.cwd()`. Run `npx appkit-init-config`
+ * to generate a starter file.
+ *
+ * @example
+ * ```ts
+ * // appkit.config.ts
+ * import type { AppkitConfig } from "@mohasinac/appkit";
+ * const config: AppkitConfig = {
+ *   baseUrl: "http://localhost:3000",
+ *   locales: ["en"],
+ *   routes: {
+ *     smoke: [{ path: "/", expect: ["LetItRip"] }],
+ *   },
+ * };
+ * export default config;
+ * ```
+ */
+export interface AppkitSmokeRoute {
+    /** Relative path, e.g. "/" or "/products/some-slug" */
+    path: string;
+    /** Strings that must appear in the initial HTML (no JS evaluated) */
+    expect: string[];
+    /** Optional auth fixture key from authFixtures */
+    auth?: string;
+}
+export interface AppkitThemeProbeRoute {
+    /** Relative path */
+    path: string;
+    /** Screenshot file name (without extension) */
+    screenshotName: string;
+    /** Optional auth fixture key from authFixtures */
+    auth?: string;
+}
+export interface AppkitAuthFixture {
+    /** Cookie header value, e.g. "session=FIXTURE_TOKEN" */
+    cookie: string;
+}
+export interface AppkitFirebaseConfig {
+    /** Firebase project ID */
+    projectId: string;
+    /** Path to firestore.indexes.json base file */
+    indexesPath?: string;
+    /** Collections to include in reset (undefined = all) */
+    resetCollections?: string[];
+    /** Firebase Functions region */
+    functionsRegion?: string;
+}
+export interface AppkitVercelConfig {
+    /** Vercel project ID */
+    projectId: string;
+    /** Vercel team slug or ID */
+    team?: string;
+    /** Path to .env file to sync */
+    envFile?: string;
+}
+export interface AppkitConfig {
+    /** Base URL for smoke tests and theme probes (default: http://localhost:3000) */
+    baseUrl?: string;
+    /** Supported locales (default: ["en"]) */
+    locales?: string[];
+    /** Route configuration for smoke tests and theme probing */
+    routes?: {
+        /** Routes to SSR-verify: must return 200 + expected strings in initial HTML */
+        smoke?: AppkitSmokeRoute[];
+        /** Routes to screenshot for theme-repaint verification */
+        themeProbe?: AppkitThemeProbeRoute[];
+    };
+    /** Strings that must NOT appear in any client bundle chunk */
+    bundleForbidden?: string[];
+    /** Named auth fixtures for smoke/theme tests */
+    authFixtures?: Record<string, AppkitAuthFixture>;
+    /** CSS custom property overrides for theme-swap verification */
+    themeOverrides?: Record<string, string>;
+    /** Firebase project configuration (used by firebase-* CLI binaries) */
+    firebase?: AppkitFirebaseConfig;
+    /** Vercel project configuration (used by vercel-* CLI binaries) */
+    vercel?: AppkitVercelConfig;
+}

package/dist/_internal/shared/config/schema.js

@@ -0,0 +1 @@
+export {};

package/dist/_internal/shared/constants/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/_internal/shared/constants/index.js

@@ -0,0 +1 @@
+export {};

package/dist/_internal/shared/errors/index.d.ts

@@ -0,0 +1,24 @@
+/** Base domain error — all appkit errors extend this. */
+export declare class AppkitError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+export declare class NotFoundError extends AppkitError {
+    constructor(resource: string, id?: string);
+}
+export declare class ValidationError extends AppkitError {
+    readonly field?: string | undefined;
+    constructor(message: string, field?: string | undefined);
+}
+export declare class UnauthorizedError extends AppkitError {
+    constructor(action?: string);
+}
+export declare class ConflictError extends AppkitError {
+    constructor(message: string);
+}
+export declare class CapacityError extends AppkitError {
+    constructor(message: string);
+}
+export declare class ExpiredError extends AppkitError {
+    constructor(resource: string);
+}

package/dist/_internal/shared/errors/index.js

@@ -0,0 +1,46 @@
+/** Base domain error — all appkit errors extend this. */
+export class AppkitError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "AppkitError";
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+export class NotFoundError extends AppkitError {
+    constructor(resource, id) {
+        super(id ? `${resource} not found: ${id}` : resource, "NOT_FOUND");
+        this.name = "NotFoundError";
+    }
+}
+export class ValidationError extends AppkitError {
+    constructor(message, field) {
+        super(message, "VALIDATION_ERROR");
+        this.field = field;
+        this.name = "ValidationError";
+    }
+}
+export class UnauthorizedError extends AppkitError {
+    constructor(action) {
+        super(action ? `Unauthorized: ${action}` : "Unauthorized", "UNAUTHORIZED");
+        this.name = "UnauthorizedError";
+    }
+}
+export class ConflictError extends AppkitError {
+    constructor(message) {
+        super(message, "CONFLICT");
+        this.name = "ConflictError";
+    }
+}
+export class CapacityError extends AppkitError {
+    constructor(message) {
+        super(message, "CAPACITY_EXCEEDED");
+        this.name = "CapacityError";
+    }
+}
+export class ExpiredError extends AppkitError {
+    constructor(resource) {
+        super(`${resource} has expired`, "EXPIRED");
+        this.name = "ExpiredError";
+    }
+}

package/dist/_internal/shared/features/auctions/config.d.ts

@@ -0,0 +1,6 @@
+export declare const AUCTIONS_PAGE_SIZE = 20;
+export declare const AUCTIONS_ACTIVE_LIMIT = 50;
+export declare const AUCTIONS_SITEMAP_LIMIT = 5000;
+export declare const AUCTION_DEFAULT_EXTENSION_MINUTES = 5;
+export declare const AUCTION_MIN_BID_INCREMENT_PAISE = 100;
+export declare const AUCTION_SNIPING_WINDOW_SECONDS = 300;

package/dist/_internal/shared/features/auctions/config.js

@@ -0,0 +1,6 @@
+export const AUCTIONS_PAGE_SIZE = 20;
+export const AUCTIONS_ACTIVE_LIMIT = 50;
+export const AUCTIONS_SITEMAP_LIMIT = 5000;
+export const AUCTION_DEFAULT_EXTENSION_MINUTES = 5;
+export const AUCTION_MIN_BID_INCREMENT_PAISE = 100; // ₹1
+export const AUCTION_SNIPING_WINDOW_SECONDS = 300; // 5 minutes — triggers auto-extend

package/dist/_internal/shared/features/auctions/errors.d.ts

@@ -0,0 +1,16 @@
+import { NotFoundError, ValidationError, ConflictError, ExpiredError } from "../../errors/index";
+export declare class AuctionNotFoundError extends NotFoundError {
+    constructor(id: string);
+}
+export declare class AuctionEndedError extends ExpiredError {
+    constructor(id: string);
+}
+export declare class BidTooLowError extends ValidationError {
+    constructor(minBid: number);
+}
+export declare class BidOnOwnAuctionError extends ConflictError {
+    constructor();
+}
+export declare class AuctionReserveNotMetError extends ConflictError {
+    constructor();
+}

package/dist/_internal/shared/features/auctions/errors.js

@@ -0,0 +1,31 @@
+import { NotFoundError, ValidationError, ConflictError, ExpiredError } from "../../errors/index";
+export class AuctionNotFoundError extends NotFoundError {
+    constructor(id) {
+        super("Auction", id);
+        this.name = "AuctionNotFoundError";
+    }
+}
+export class AuctionEndedError extends ExpiredError {
+    constructor(id) {
+        super(`Auction ${id}`);
+        this.name = "AuctionEndedError";
+    }
+}
+export class BidTooLowError extends ValidationError {
+    constructor(minBid) {
+        super(`Bid must be at least ₹${(minBid / 100).toLocaleString("en-IN")} (${minBid} paise)`, "amount");
+        this.name = "BidTooLowError";
+    }
+}
+export class BidOnOwnAuctionError extends ConflictError {
+    constructor() {
+        super("Sellers cannot bid on their own auctions");
+        this.name = "BidOnOwnAuctionError";
+    }
+}
+export class AuctionReserveNotMetError extends ConflictError {
+    constructor() {
+        super("Reserve price has not been met");
+        this.name = "AuctionReserveNotMetError";
+    }
+}

package/dist/_internal/shared/features/auctions/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export declare const placeBidSchema: z.ZodObject<{
+    auctionId: z.ZodString;
+    amount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    amount: number;
+    auctionId: string;
+}, {
+    amount: number;
+    auctionId: string;
+}>;
+export declare const cancelBidSchema: z.ZodObject<{
+    bidId: z.ZodString;
+    auctionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    auctionId: string;
+    bidId: string;
+}, {
+    auctionId: string;
+    bidId: string;
+}>;
+export declare const buyNowSchema: z.ZodObject<{
+    auctionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    auctionId: string;
+}, {
+    auctionId: string;
+}>;
+export type PlaceBidInput = z.infer<typeof placeBidSchema>;
+export type CancelBidInput = z.infer<typeof cancelBidSchema>;

package/dist/_internal/shared/features/auctions/schema.js

@@ -0,0 +1,12 @@
+import { z } from "zod";
+export const placeBidSchema = z.object({
+    auctionId: z.string().min(1),
+    amount: z.number().int().positive("Bid amount must be a positive integer (paise)"),
+});
+export const cancelBidSchema = z.object({
+    bidId: z.string().min(1),
+    auctionId: z.string().min(1),
+});
+export const buyNowSchema = z.object({
+    auctionId: z.string().min(1),
+});

package/dist/_internal/shared/features/blog/config.d.ts

@@ -0,0 +1,6 @@
+export declare const BLOG_PAGE_SIZE = 12;
+export declare const BLOG_FEATURED_LIMIT = 3;
+export declare const BLOG_RELATED_LIMIT = 4;
+export declare const BLOG_SITEMAP_LIMIT = 5000;
+export declare const BLOG_TITLE_MAX_LENGTH = 200;
+export declare const BLOG_EXCERPT_MAX_LENGTH = 300;

package/dist/_internal/shared/features/blog/config.js

@@ -0,0 +1,6 @@
+export const BLOG_PAGE_SIZE = 12;
+export const BLOG_FEATURED_LIMIT = 3;
+export const BLOG_RELATED_LIMIT = 4;
+export const BLOG_SITEMAP_LIMIT = 5000;
+export const BLOG_TITLE_MAX_LENGTH = 200;
+export const BLOG_EXCERPT_MAX_LENGTH = 300;

package/dist/_internal/shared/features/blog/errors.d.ts

@@ -0,0 +1,10 @@
+import { NotFoundError, UnauthorizedError, ConflictError } from "../../errors/index";
+export declare class BlogPostNotFoundError extends NotFoundError {
+    constructor(slug: string);
+}
+export declare class BlogPostNotPublishedError extends UnauthorizedError {
+    constructor(slug: string);
+}
+export declare class BlogSlugConflictError extends ConflictError {
+    constructor(slug: string);
+}

package/dist/_internal/shared/features/blog/errors.js

@@ -0,0 +1,19 @@
+import { NotFoundError, UnauthorizedError, ConflictError } from "../../errors/index";
+export class BlogPostNotFoundError extends NotFoundError {
+    constructor(slug) {
+        super("Blog post", slug);
+        this.name = "BlogPostNotFoundError";
+    }
+}
+export class BlogPostNotPublishedError extends UnauthorizedError {
+    constructor(slug) {
+        super(`view unpublished blog post ${slug}`);
+        this.name = "BlogPostNotPublishedError";
+    }
+}
+export class BlogSlugConflictError extends ConflictError {
+    constructor(slug) {
+        super(`A blog post with slug "${slug}" already exists`);
+        this.name = "BlogSlugConflictError";
+    }
+}

package/dist/_internal/shared/features/blog/schema.d.ts

@@ -0,0 +1,81 @@
+import { z } from "zod";
+export declare const blogPostInputSchema: z.ZodObject<{
+    title: z.ZodString;
+    slug: z.ZodString;
+    excerpt: z.ZodOptional<z.ZodString>;
+    content: z.ZodString;
+    coverImage: z.ZodOptional<z.ZodString>;
+    youtubeId: z.ZodOptional<z.ZodString>;
+    category: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    status: z.ZodDefault<z.ZodEnum<["draft", "published"]>>;
+    isFeatured: z.ZodDefault<z.ZodBoolean>;
+    metaTitle: z.ZodOptional<z.ZodString>;
+    metaDescription: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "draft" | "published";
+    title: string;
+    content: string;
+    category: string;
+    slug: string;
+    tags: string[];
+    isFeatured: boolean;
+    youtubeId?: string | undefined;
+    coverImage?: string | undefined;
+    excerpt?: string | undefined;
+    metaTitle?: string | undefined;
+    metaDescription?: string | undefined;
+}, {
+    title: string;
+    content: string;
+    category: string;
+    slug: string;
+    status?: "draft" | "published" | undefined;
+    youtubeId?: string | undefined;
+    tags?: string[] | undefined;
+    isFeatured?: boolean | undefined;
+    coverImage?: string | undefined;
+    excerpt?: string | undefined;
+    metaTitle?: string | undefined;
+    metaDescription?: string | undefined;
+}>;
+export declare const blogPostUpdateSchema: z.ZodObject<Omit<{
+    title: z.ZodOptional<z.ZodString>;
+    slug: z.ZodOptional<z.ZodString>;
+    excerpt: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    content: z.ZodOptional<z.ZodString>;
+    coverImage: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    youtubeId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    category: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
+    status: z.ZodOptional<z.ZodDefault<z.ZodEnum<["draft", "published"]>>>;
+    isFeatured: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    metaTitle: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    metaDescription: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+}, "slug">, "strip", z.ZodTypeAny, {
+    status?: "draft" | "published" | undefined;
+    title?: string | undefined;
+    content?: string | undefined;
+    category?: string | undefined;
+    youtubeId?: string | undefined;
+    tags?: string[] | undefined;
+    isFeatured?: boolean | undefined;
+    coverImage?: string | undefined;
+    excerpt?: string | undefined;
+    metaTitle?: string | undefined;
+    metaDescription?: string | undefined;
+}, {
+    status?: "draft" | "published" | undefined;
+    title?: string | undefined;
+    content?: string | undefined;
+    category?: string | undefined;
+    youtubeId?: string | undefined;
+    tags?: string[] | undefined;
+    isFeatured?: boolean | undefined;
+    coverImage?: string | undefined;
+    excerpt?: string | undefined;
+    metaTitle?: string | undefined;
+    metaDescription?: string | undefined;
+}>;
+export type BlogPostInput = z.infer<typeof blogPostInputSchema>;
+export type BlogPostUpdate = z.infer<typeof blogPostUpdateSchema>;

package/dist/_internal/shared/features/blog/schema.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import { BLOG_TITLE_MAX_LENGTH, BLOG_EXCERPT_MAX_LENGTH } from "./config";
+export const blogPostInputSchema = z.object({
+    title: z.string().min(3).max(BLOG_TITLE_MAX_LENGTH),
+    slug: z.string().min(1).regex(/^blog-[a-z0-9-]+$/, "Slug must start with 'blog-'"),
+    excerpt: z.string().max(BLOG_EXCERPT_MAX_LENGTH).optional(),
+    content: z.string().max(100000),
+    coverImage: z.string().url().optional(),
+    youtubeId: z.string().optional(),
+    category: z.string().min(1),
+    tags: z.array(z.string()).max(10).default([]),
+    status: z.enum(["draft", "published"]).default("draft"),
+    isFeatured: z.boolean().default(false),
+    metaTitle: z.string().max(70).optional(),
+    metaDescription: z.string().max(160).optional(),
+});
+export const blogPostUpdateSchema = blogPostInputSchema.partial().omit({ slug: true });

package/dist/_internal/shared/features/brands/config.d.ts

@@ -0,0 +1,4 @@
+export declare const BRANDS_PAGE_SIZE = 50;
+export declare const BRANDS_FEATURED_LIMIT = 12;
+export declare const BRAND_NAME_MAX_LENGTH = 100;
+export declare const BRAND_DESCRIPTION_MAX_LENGTH = 2000;

package/dist/_internal/shared/features/brands/config.js

@@ -0,0 +1,4 @@
+export const BRANDS_PAGE_SIZE = 50;
+export const BRANDS_FEATURED_LIMIT = 12;
+export const BRAND_NAME_MAX_LENGTH = 100;
+export const BRAND_DESCRIPTION_MAX_LENGTH = 2000;