npm - @mohasinac/appkit - Versions diffs - 2.8.9 → 3.0.0 - Mend

@mohasinac/appkit 2.8.9 → 3.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1289) hide show

package/dist/_internal/client/theme/__tests__/ThemeProvider.test.js ADDED Viewed

@@ -0,0 +1,109 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { render, screen, act } from "@testing-library/react";
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { ThemeProvider, useTheme } from "../ThemeProvider";
+import { buildThemeRegistry } from "../buildRegistry";
+import { DEFAULT_DARK_THEME, DEFAULT_LIGHT_THEME, } from "../../../../tokens/themes";
+const MEDIA_QUERY = "(prefers-color-scheme: dark)";
+function mockMatchMedia(prefersDark) {
+    const listeners = [];
+    Object.defineProperty(window, "matchMedia", {
+        writable: true,
+        value: (query) => ({
+            matches: query === MEDIA_QUERY ? prefersDark : false,
+            media: query,
+            onchange: null,
+            addEventListener: (_event, cb) => listeners.push(cb),
+            removeEventListener: (_event, cb) => {
+                const idx = listeners.indexOf(cb);
+                if (idx !== -1)
+                    listeners.splice(idx, 1);
+            },
+            addListener: () => undefined,
+            removeListener: () => undefined,
+            dispatchEvent: () => true,
+        }),
+    });
+    return listeners;
+}
+function Probe() {
+    const { effectiveMode, activeTheme, preference } = useTheme();
+    return (_jsxs("div", { "data-testid": "probe", children: ["mode=", effectiveMode, " pref=", preference, " themeId=", activeTheme.id] }));
+}
+describe("ThemeProvider", () => {
+    beforeEach(() => {
+        window.localStorage.clear();
+        document.documentElement.removeAttribute("data-theme");
+        document.documentElement.className = "";
+        document.documentElement.style.cssText = "";
+    });
+    it("applies the default light theme when prefers-color-scheme is light", () => {
+        mockMatchMedia(false);
+        render(_jsx(ThemeProvider, { children: _jsx(Probe, {}) }));
+        expect(screen.getByTestId("probe").textContent).toContain(`themeId=${DEFAULT_LIGHT_THEME.id}`);
+        expect(document.documentElement.getAttribute("data-theme")).toBe(DEFAULT_LIGHT_THEME.id);
+    });
+    it("applies the default dark theme when prefers-color-scheme is dark", () => {
+        mockMatchMedia(true);
+        render(_jsx(ThemeProvider, { children: _jsx(Probe, {}) }));
+        expect(screen.getByTestId("probe").textContent).toContain(`themeId=${DEFAULT_DARK_THEME.id}`);
+        expect(document.documentElement.classList.contains("dark")).toBe(true);
+    });
+    it("toggleTheme flips preference between light and dark", () => {
+        mockMatchMedia(false);
+        const captured = {
+            current: null,
+        };
+        function Capture() {
+            captured.current = useTheme();
+            return null;
+        }
+        render(_jsx(ThemeProvider, { children: _jsx(Capture, {}) }));
+        expect(captured.current?.effectiveMode).toBe("light");
+        act(() => captured.current?.toggleTheme());
+        expect(captured.current?.effectiveMode).toBe("dark");
+        expect(captured.current?.preference).toBe("dark");
+    });
+    it("writes inline CSS variables from the active theme to <html>", () => {
+        mockMatchMedia(false);
+        render(_jsx(ThemeProvider, { children: _jsx(Probe, {}) }));
+        expect(document.documentElement.style.getPropertyValue("--appkit-color-primary")).toBe(DEFAULT_LIGHT_THEME.tokens["appkit-color-primary"]);
+    });
+    it("buildThemeRegistry falls back to built-ins for missing ids", () => {
+        const registry = buildThemeRegistry({
+            themes: [],
+            defaultLightThemeId: "missing",
+            defaultDarkThemeId: "missing-too",
+        });
+        expect(registry.defaultLightThemeId).toBe(DEFAULT_LIGHT_THEME.id);
+        expect(registry.defaultDarkThemeId).toBe(DEFAULT_DARK_THEME.id);
+    });
+    it("buildThemeRegistry merges admin records with built-ins", () => {
+        const adminTheme = {
+            id: "sunset-bright",
+            name: "Sunset Bright",
+            mode: "light",
+            builtIn: false,
+            tokens: { "appkit-color-primary": "#ff9900" },
+            gradients: {},
+        };
+        const registry = buildThemeRegistry({
+            themes: [adminTheme],
+            defaultLightThemeId: "sunset-bright",
+            defaultDarkThemeId: DEFAULT_DARK_THEME.id,
+        });
+        expect(registry.defaultLightThemeId).toBe("sunset-bright");
+        expect(registry.themes.find((t) => t.id === "sunset-bright")).toBeDefined();
+        expect(registry.themes.find((t) => t.id === DEFAULT_LIGHT_THEME.id)).toBeDefined();
+    });
+    it("useTheme throws outside the provider", () => {
+        // Suppress the expected console.error from React.
+        const spy = vi.spyOn(console, "error").mockImplementation(() => undefined);
+        function Naked() {
+            useTheme();
+            return null;
+        }
+        expect(() => render(_jsx(Naked, {}))).toThrow(/useTheme/);
+        spy.mockRestore();
+    });
+});

package/dist/_internal/client/theme/buildRegistry.d.ts ADDED Viewed

@@ -0,0 +1,29 @@
+import type { ThemeRegistry } from "./ThemeProvider";
+/**
+ * Minimal shape this helper needs from `siteSettings.theme`. Kept loose so the
+ * consumer can pass the live document or a stripped-down server-action payload
+ * without dragging in the admin schemas package.
+ */
+export interface SiteSettingsThemeInput {
+    themes?: Array<{
+        id: string;
+        name: string;
+        mode: "light" | "dark";
+        builtIn?: boolean;
+        tokens: Record<string, string>;
+        gradients: Record<string, string>;
+    }>;
+    defaultLightThemeId?: string;
+    defaultDarkThemeId?: string;
+}
+/**
+ * Build a runtime theme registry from `siteSettings.theme`.
+ *
+ * - Built-in themes (`default-light`, `default-dark`) are always present, even
+ *   if the admin tries to omit them from the stored list.
+ * - Admin-authored records override built-ins of the same id (allows the admin
+ *   to override the default palette without losing the built-in fallback path).
+ * - `defaultLightThemeId` / `defaultDarkThemeId` fall back to the built-ins when
+ *   the stored ids are missing or point at a record whose mode does not match.
+ */
+export declare function buildThemeRegistry(input: SiteSettingsThemeInput | undefined | null): ThemeRegistry;

package/dist/_internal/client/theme/buildRegistry.js ADDED Viewed

@@ -0,0 +1,37 @@
+import { BUILT_IN_THEMES, DEFAULT_DARK_THEME, DEFAULT_LIGHT_THEME, } from "../../../tokens/themes";
+/**
+ * Build a runtime theme registry from `siteSettings.theme`.
+ *
+ * - Built-in themes (`default-light`, `default-dark`) are always present, even
+ *   if the admin tries to omit them from the stored list.
+ * - Admin-authored records override built-ins of the same id (allows the admin
+ *   to override the default palette without losing the built-in fallback path).
+ * - `defaultLightThemeId` / `defaultDarkThemeId` fall back to the built-ins when
+ *   the stored ids are missing or point at a record whose mode does not match.
+ */
+export function buildThemeRegistry(input) {
+    const byId = new Map();
+    for (const built of BUILT_IN_THEMES) {
+        byId.set(built.id, built);
+    }
+    for (const admin of input?.themes ?? []) {
+        byId.set(admin.id, {
+            id: admin.id,
+            name: admin.name,
+            mode: admin.mode,
+            builtIn: Boolean(admin.builtIn),
+            tokens: admin.tokens,
+            gradients: admin.gradients,
+        });
+    }
+    const themes = Array.from(byId.values());
+    const wantedLight = input?.defaultLightThemeId ?? DEFAULT_LIGHT_THEME.id;
+    const wantedDark = input?.defaultDarkThemeId ?? DEFAULT_DARK_THEME.id;
+    const lightMatches = themes.find((t) => t.id === wantedLight && t.mode === "light");
+    const darkMatches = themes.find((t) => t.id === wantedDark && t.mode === "dark");
+    return {
+        themes,
+        defaultLightThemeId: lightMatches?.id ?? DEFAULT_LIGHT_THEME.id,
+        defaultDarkThemeId: darkMatches?.id ?? DEFAULT_DARK_THEME.id,
+    };
+}

package/dist/_internal/client/theme/index.d.ts ADDED Viewed

@@ -0,0 +1,4 @@
+export { ThemeProvider, useTheme } from "./ThemeProvider";
+export type { ModePreference, ThemeContextValue, ThemeProviderProps, ThemeRegistry, } from "./ThemeProvider";
+export { buildThemeRegistry } from "./buildRegistry";
+export type { SiteSettingsThemeInput } from "./buildRegistry";

package/dist/_internal/client/theme/index.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export { ThemeProvider, useTheme } from "./ThemeProvider";
2	+ export { buildThemeRegistry } from "./buildRegistry";

package/dist/_internal/server/features/auctions/actions.d.ts CHANGED Viewed

@@ -1 +1,2 @@
-export declare function placeBidAction(input: unknown): Promise<import("../../../..").BidDocument>;
+import { type ActionResult } from "@mohasinac/appkit/server";
+export declare function placeBidAction(input: unknown): Promise<ActionResult<unknown>>;

package/dist/_internal/server/features/auctions/actions.js CHANGED Viewed

@@ -1,44 +1,48 @@
 "use server";
+import { wrapAction } from "@mohasinac/appkit/server";
 import { bidRepository, productRepository, userRepository } from "../../../../repositories";
 import { requireRoleUser } from "../../../../providers/auth-firebase/helpers";
 import { placeBidSchema } from "../../../shared/features/auctions/schema";
 import { assertAuctionActive, assertBidAmount, assertNotAuctionOwner, shouldAutoExtend, computeExtendedEndDate, } from "./service";
 import { ValidationError } from "../../../shared/errors/index";
+// audit-unknown-ok: callback entry point — accepts arbitrary payload value
 export async function placeBidAction(input) {
-    const user = await requireRoleUser(["buyer", "seller", "admin"]);
-    const parsed = placeBidSchema.safeParse(input);
-    if (!parsed.success)
-        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid bid input");
-    const { auctionId, amount } = parsed.data;
-    const product = await assertAuctionActive(auctionId);
-    assertNotAuctionOwner(product, user.uid);
-    assertBidAmount(product, amount);
-    const profile = await userRepository.findById(user.uid).catch(() => null);
-    const userName = profile?.displayName ?? user.name ?? "Anonymous";
-    // Mark all current bids for this auction as outbid, then set new winning bid
-    await bidRepository.setWinningBid("__placeholder__", auctionId).catch(() => null);
-    const bid = await bidRepository.create({
-        productId: auctionId,
-        productTitle: product.title ?? auctionId,
-        userId: user.uid,
-        userName,
-        userEmail: user.email ?? "",
-        bidAmount: amount,
-        currency: product.currency ?? "INR",
-        bidDate: new Date(),
-    });
-    // Now set this new bid as the winning bid
-    await bidRepository.setWinningBid(bid.id, auctionId);
-    const updates = {
-        currentBid: amount,
-        bidCount: (product.bidCount ?? 0) + 1,
-    };
-    if (shouldAutoExtend(product)) {
-        updates.auctionEndDate = computeExtendedEndDate(product);
-        if (!product.auctionOriginalEndDate) {
-            updates.auctionOriginalEndDate = product.auctionEndDate;
+    return wrapAction(async () => {
+        const user = await requireRoleUser(["buyer", "seller", "admin"]);
+        const parsed = placeBidSchema.safeParse(input);
+        if (!parsed.success)
+            throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid bid input");
+        const { auctionId, amount } = parsed.data;
+        const product = await assertAuctionActive(auctionId);
+        assertNotAuctionOwner(product, user.uid);
+        assertBidAmount(product, amount);
+        const profile = await userRepository.findById(user.uid).catch(() => null);
+        const userName = profile?.displayName ?? user.name ?? "Anonymous";
+        // Mark all current bids for this auction as outbid, then set new winning bid
+        await bidRepository.setWinningBid("__placeholder__", auctionId).catch(() => null);
+        const bid = await bidRepository.create({
+            productId: auctionId,
+            productTitle: product.title ?? auctionId,
+            userId: user.uid,
+            userName,
+            userEmail: user.email ?? "",
+            bidAmount: amount,
+            currency: product.currency ?? "INR",
+            bidDate: new Date(),
+        });
+        // Now set this new bid as the winning bid
+        await bidRepository.setWinningBid(bid.id, auctionId);
+        const updates = {
+            currentBid: amount,
+            bidCount: (product.bidCount ?? 0) + 1,
+        };
+        if (shouldAutoExtend(product)) {
+            updates.auctionEndDate = computeExtendedEndDate(product);
+            if (!product.auctionOriginalEndDate) {
+                updates.auctionOriginalEndDate = product.auctionEndDate;
+            }
         }
-    }
-    await productRepository.update(auctionId, updates);
-    return bid;
+        await productRepository.update(auctionId, updates);
+        return bid;
+    });
 }

package/dist/_internal/server/features/auctions/og.js CHANGED Viewed

@@ -6,6 +6,7 @@ export function renderAuctionOg(doc, opts) {
     const endDate = doc?.auctionEndDate
         ? doc.auctionEndDate instanceof Date
             ? doc.auctionEndDate
+            // audit-unknown-ok: TS structural escape — primitive cast
             : new Date(doc.auctionEndDate)
         : null;
     const endsLabel = endDate

package/dist/_internal/server/features/auctions/service.js CHANGED Viewed

@@ -10,10 +10,12 @@ export async function assertAuctionActive(auctionId) {
     const endDate = product.auctionEndDate instanceof Date
         ? product.auctionEndDate
         : product.auctionEndDate
+            // audit-unknown-ok: TS structural escape — primitive cast
             ? new Date(product.auctionEndDate)
             : null;
     if (!endDate || endDate.getTime() <= Date.now())
         throw new AuctionEndedError(auctionId);
+    // audit-unknown-ok: TS structural escape — domain document type lacks index signature
     return product;
 }
 /** Compute the minimum valid bid given the current state. */
@@ -40,6 +42,7 @@ export function shouldAutoExtend(product) {
     const endDate = product.auctionEndDate instanceof Date
         ? product.auctionEndDate
         : product.auctionEndDate
+            // audit-unknown-ok: TS structural escape — primitive cast
             ? new Date(product.auctionEndDate)
             : null;
     if (!endDate)
@@ -51,6 +54,7 @@ export function shouldAutoExtend(product) {
 export function computeExtendedEndDate(product) {
     const current = product.auctionEndDate instanceof Date
         ? product.auctionEndDate
+        // audit-unknown-ok: TS structural escape — primitive cast
         : new Date(product.auctionEndDate);
     const extensionMs = (product.auctionExtensionMinutes ?? AUCTION_DEFAULT_EXTENSION_MINUTES) * 60 * 1000;
     return new Date(current.getTime() + extensionMs);

package/dist/_internal/server/features/auth/capabilities.js CHANGED Viewed

@@ -16,6 +16,7 @@ export async function getStoreCapabilities(storeId) {
     const store = await storeRepository.findById(storeId);
     if (!store)
         return [...DEFAULT_STORE_CAPABILITIES];
+    // audit-unknown-ok: TS structural escape — domain document type lacks index signature
     const raw = store.capabilities;
     if (Array.isArray(raw) && raw.length > 0)
         return raw;

package/dist/_internal/server/features/blog/actions.d.ts CHANGED Viewed

@@ -1,5 +1,6 @@
-export declare function createBlogPostAction(input: unknown): Promise<import("../../../..").BlogPostDocument>;
-export declare function updateBlogPostAction(postId: string, input: unknown): Promise<import("../../../..").BlogPostDocument>;
-export declare function deleteBlogPostAction(postId: string): Promise<void>;
-export declare function publishBlogPostAction(postId: string): Promise<import("../../../..").BlogPostDocument>;
-export declare function unpublishBlogPostAction(postId: string): Promise<import("../../../..").BlogPostDocument>;
+import { type ActionResult } from "@mohasinac/appkit/server";
+export declare function createBlogPostAction(input: unknown): Promise<ActionResult<unknown>>;
+export declare function updateBlogPostAction(postId: string, input: unknown): Promise<ActionResult<unknown>>;
+export declare function deleteBlogPostAction(postId: string): Promise<ActionResult<unknown>>;
+export declare function publishBlogPostAction(postId: string): Promise<ActionResult<unknown>>;
+export declare function unpublishBlogPostAction(postId: string): Promise<ActionResult<unknown>>;

package/dist/_internal/server/features/blog/actions.js CHANGED Viewed

@@ -1,51 +1,64 @@
 "use server";
+import { wrapAction } from "@mohasinac/appkit/server";
 import { blogRepository } from "../../../../repositories";
 import { requireRoleUser } from "../../../../providers/auth-firebase/helpers";
 import { blogPostInputSchema, blogPostUpdateSchema } from "../../../shared/features/blog/schema";
 import { assertBlogPostExists, assertBlogSlugUnique, computeReadTime } from "./service";
 import { ValidationError } from "../../../shared/errors/index";
+// audit-unknown-ok: callback entry point — accepts arbitrary payload value
 export async function createBlogPostAction(input) {
-    const user = await requireRoleUser(["admin", "moderator"]);
-    const parsed = blogPostInputSchema.safeParse(input);
-    if (!parsed.success)
-        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid blog post input");
-    await assertBlogSlugUnique(parsed.data.slug);
-    const readTime = computeReadTime(parsed.data.content);
-    return blogRepository.createWithId(parsed.data.slug, {
-        ...parsed.data,
-        authorId: user.uid,
-        authorName: user.name ?? "Editorial Team",
-        readTimeMinutes: readTime,
-        views: 0,
-        publishedAt: parsed.data.status === "published" ? new Date() : undefined,
+    return wrapAction(async () => {
+        const user = await requireRoleUser(["admin", "moderator"]);
+        const parsed = blogPostInputSchema.safeParse(input);
+        if (!parsed.success)
+            throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid blog post input");
+        await assertBlogSlugUnique(parsed.data.slug);
+        const readTime = computeReadTime(parsed.data.content);
+        return blogRepository.createWithId(parsed.data.slug, {
+            ...parsed.data,
+            authorId: user.uid,
+            authorName: user.name ?? "Editorial Team",
+            readTimeMinutes: readTime,
+            views: 0,
+            publishedAt: parsed.data.status === "published" ? new Date() : undefined,
+        });
     });
 }
+// audit-unknown-ok: callback entry point — accepts arbitrary payload value
 export async function updateBlogPostAction(postId, input) {
-    await requireRoleUser(["admin", "moderator"]);
-    const post = await assertBlogPostExists(postId);
-    const parsed = blogPostUpdateSchema.safeParse(input);
-    if (!parsed.success)
-        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid blog post input");
-    const updates = { ...parsed.data };
-    if (parsed.data.content)
-        updates.readTimeMinutes = computeReadTime(parsed.data.content);
-    if (parsed.data.status === "published" && post.status !== "published") {
-        updates.publishedAt = new Date();
-    }
-    return blogRepository.update(postId, updates);
+    return wrapAction(async () => {
+        await requireRoleUser(["admin", "moderator"]);
+        const post = await assertBlogPostExists(postId);
+        const parsed = blogPostUpdateSchema.safeParse(input);
+        if (!parsed.success)
+            throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid blog post input");
+        const updates = { ...parsed.data };
+        if (parsed.data.content)
+            updates.readTimeMinutes = computeReadTime(parsed.data.content);
+        if (parsed.data.status === "published" && post.status !== "published") {
+            updates.publishedAt = new Date();
+        }
+        return blogRepository.update(postId, updates);
+    });
 }
 export async function deleteBlogPostAction(postId) {
-    await requireRoleUser("admin");
-    await assertBlogPostExists(postId);
-    return blogRepository.delete(postId);
+    return wrapAction(async () => {
+        await requireRoleUser("admin");
+        await assertBlogPostExists(postId);
+        return blogRepository.delete(postId);
+    });
 }
 export async function publishBlogPostAction(postId) {
-    await requireRoleUser(["admin", "moderator"]);
-    await assertBlogPostExists(postId);
-    return blogRepository.update(postId, { status: "published", publishedAt: new Date() });
+    return wrapAction(async () => {
+        await requireRoleUser(["admin", "moderator"]);
+        await assertBlogPostExists(postId);
+        return blogRepository.update(postId, { status: "published", publishedAt: new Date() });
+    });
 }
 export async function unpublishBlogPostAction(postId) {
-    await requireRoleUser(["admin", "moderator"]);
-    await assertBlogPostExists(postId);
-    return blogRepository.update(postId, { status: "draft" });
+    return wrapAction(async () => {
+        await requireRoleUser(["admin", "moderator"]);
+        await assertBlogPostExists(postId);
+        return blogRepository.update(postId, { status: "draft" });
+    });
 }

package/dist/_internal/server/features/brands/actions.d.ts CHANGED Viewed

@@ -1,4 +1,5 @@
-export declare function createBrandAction(input: unknown): Promise<import("../../../..").CategoryDocument>;
-export declare function updateBrandAction(brandId: string, input: unknown): Promise<import("../../../..").CategoryDocument>;
-export declare function deleteBrandAction(brandId: string): Promise<void>;
-export declare function toggleBrandActiveAction(brandId: string, isActive: boolean): Promise<import("../../../..").CategoryDocument>;
+import { type ActionResult } from "@mohasinac/appkit/server";
+export declare function createBrandAction(input: unknown): Promise<ActionResult<unknown>>;
+export declare function updateBrandAction(brandId: string, input: unknown): Promise<ActionResult<unknown>>;
+export declare function deleteBrandAction(brandId: string): Promise<ActionResult<unknown>>;
+export declare function toggleBrandActiveAction(brandId: string, isActive: boolean): Promise<ActionResult<unknown>>;

package/dist/_internal/server/features/brands/actions.js CHANGED Viewed

@@ -1,4 +1,5 @@
 "use server";
+import { wrapAction } from "@mohasinac/appkit/server";
 import { categoriesRepository } from "../../../../repositories";
 import { requireRoleUser } from "../../../../providers/auth-firebase/helpers";
 import { brandInputSchema, brandUpdateSchema } from "../../../shared/features/brands/schema";
@@ -36,64 +37,74 @@ function brandInputToCategoryFields(input) {
         out.order = input.displayOrder;
     return out;
 }
+// audit-unknown-ok: callback entry point — accepts arbitrary payload value
 export async function createBrandAction(input) {
-    await requireRoleUser("admin");
-    const parsed = brandInputSchema.safeParse(input);
-    if (!parsed.success)
-        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid brand input");
-    await assertBrandSlugUnique(parsed.data.slug);
-    const fields = brandInputToCategoryFields(parsed.data);
-    return categoriesRepository.createWithId(parsed.data.slug, {
-        id: parsed.data.slug,
-        name: parsed.data.name,
-        slug: parsed.data.slug,
-        categoryType: "brand",
-        rootId: parsed.data.slug,
-        parentIds: [],
-        childrenIds: [],
-        tier: 0,
-        path: parsed.data.slug,
-        position: 0,
-        subtreeSize: 1,
-        order: parsed.data.displayOrder,
-        isLeaf: true,
-        isFeatured: false,
-        isBrand: true,
-        isActive: parsed.data.isActive,
-        isSearchable: true,
-        metrics: {
-            productCount: 0,
-            productIds: [],
-            auctionCount: 0,
-            auctionIds: [],
-            totalProductCount: 0,
-            totalAuctionCount: 0,
-            totalItemCount: 0,
-            lastUpdated: new Date(),
-        },
-        seo: { title: parsed.data.name, description: parsed.data.description ?? "", keywords: [parsed.data.name] },
-        ancestors: [],
-        createdBy: "admin",
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        ...fields,
+    return wrapAction(async () => {
+        await requireRoleUser("admin");
+        const parsed = brandInputSchema.safeParse(input);
+        if (!parsed.success)
+            throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid brand input");
+        await assertBrandSlugUnique(parsed.data.slug);
+        const fields = brandInputToCategoryFields(parsed.data);
+        return categoriesRepository.createWithId(parsed.data.slug, {
+            id: parsed.data.slug,
+            name: parsed.data.name,
+            slug: parsed.data.slug,
+            categoryType: "brand",
+            rootId: parsed.data.slug,
+            parentIds: [],
+            childrenIds: [],
+            tier: 0,
+            path: parsed.data.slug,
+            position: 0,
+            subtreeSize: 1,
+            order: parsed.data.displayOrder,
+            isLeaf: true,
+            isFeatured: false,
+            isBrand: true,
+            isActive: parsed.data.isActive,
+            isSearchable: true,
+            metrics: {
+                productCount: 0,
+                productIds: [],
+                auctionCount: 0,
+                auctionIds: [],
+                totalProductCount: 0,
+                totalAuctionCount: 0,
+                totalItemCount: 0,
+                lastUpdated: new Date(),
+            },
+            seo: { title: parsed.data.name, description: parsed.data.description ?? "", keywords: [parsed.data.name] },
+            ancestors: [],
+            createdBy: "admin",
+            createdAt: new Date(),
+            updatedAt: new Date(),
+            ...fields,
+        });
     });
 }
+// audit-unknown-ok: callback entry point — accepts arbitrary payload value
 export async function updateBrandAction(brandId, input) {
-    await requireRoleUser("admin");
-    await assertBrandExists(brandId);
-    const parsed = brandUpdateSchema.safeParse(input);
-    if (!parsed.success)
-        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid brand input");
-    return categoriesRepository.update(brandId, brandInputToCategoryFields(parsed.data));
+    return wrapAction(async () => {
+        await requireRoleUser("admin");
+        await assertBrandExists(brandId);
+        const parsed = brandUpdateSchema.safeParse(input);
+        if (!parsed.success)
+            throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid brand input");
+        return categoriesRepository.update(brandId, brandInputToCategoryFields(parsed.data));
+    });
 }
 export async function deleteBrandAction(brandId) {
-    await requireRoleUser("admin");
-    await assertBrandExists(brandId);
-    return categoriesRepository.delete(brandId);
+    return wrapAction(async () => {
+        await requireRoleUser("admin");
+        await assertBrandExists(brandId);
+        return categoriesRepository.delete(brandId);
+    });
 }
 export async function toggleBrandActiveAction(brandId, isActive) {
-    await requireRoleUser("admin");
-    await assertBrandExists(brandId);
-    return categoriesRepository.update(brandId, { isActive });
+    return wrapAction(async () => {
+        await requireRoleUser("admin");
+        await assertBrandExists(brandId);
+        return categoriesRepository.update(brandId, { isActive });
+    });
 }

package/dist/_internal/server/features/cart/actions.d.ts CHANGED Viewed

@@ -1,12 +1,5 @@
-export declare function addToCartAction(input: unknown): Promise<{
-    success: boolean;
-}>;
-export declare function removeFromCartAction(input: unknown): Promise<{
-    success: boolean;
-}>;
-export declare function clearCartAction(): Promise<{
-    success: boolean;
-}>;
-export declare function mergeGuestCartAction(input: unknown): Promise<{
-    success: boolean;
-}>;
+import { type ActionResult } from "@mohasinac/appkit/server";
+export declare function addToCartAction(input: unknown): Promise<ActionResult<unknown>>;
+export declare function removeFromCartAction(input: unknown): Promise<ActionResult<unknown>>;
+export declare function clearCartAction(): Promise<ActionResult<unknown>>;
+export declare function mergeGuestCartAction(input: unknown): Promise<ActionResult<unknown>>;