@mehdad67/apitogo 0.1.24

package/src/config/validators/InputNavigationSchema.ts

@@ -0,0 +1,206 @@
+import { z } from "zod";
+import type { UseAuthReturn } from "../../lib/authentication/hook.js";
+import type { ZudokuContext } from "../../lib/core/ZudokuContext.js";
+import type { IconNames } from "./icon-types.js";
+import type { SortableNavigationItem } from "./NavigationSchema.js";
+
+const IconSchema = z.custom<IconNames>((f) => typeof f === "string");
+
+const BadgeSchema = z.object({
+  label: z.string(),
+  // prettier-ignore
+  color: z.enum(["green", "blue", "yellow", "red", "purple", "indigo", "gray", "outline"]),
+  invert: z.boolean().optional(),
+  className: z.string().optional(),
+});
+
+const InputNavigationCategoryLinkDocSchema = z.union([
+  z.string(),
+  z.object({
+    type: z.literal("doc"),
+    file: z.string(),
+    label: z.string().optional(),
+    path: z.string().optional(),
+  }),
+]);
+
+export const DisplaySchema = z
+  .union([
+    z.enum(["auth", "anon", "always", "hide"]),
+    z.custom<
+      (params: { context: ZudokuContext; auth: UseAuthReturn }) => boolean
+    >((val) => typeof val === "function"),
+  ])
+  .optional();
+
+const NavigationModifyRuleSchema = z.object({
+  type: z.literal("modify"),
+  match: z.string(),
+  set: z.object({
+    label: z.string().optional(),
+    icon: IconSchema.optional(),
+    badge: BadgeSchema.optional(),
+    collapsed: z.boolean().optional(),
+    collapsible: z.boolean().optional(),
+    display: DisplaySchema,
+  }),
+});
+
+const NavigationInsertRuleSchema = z.object({
+  type: z.literal("insert"),
+  match: z.string(),
+  position: z.enum(["before", "after"]),
+  items: z.lazy(() => InputNavigationItemSchema.array()),
+});
+
+const NavigationRemoveRuleSchema = z.object({
+  type: z.literal("remove"),
+  match: z.string(),
+});
+
+const NavigationSortRuleSchema = z.object({
+  type: z.literal("sort"),
+  match: z.string(),
+  by: z.custom<
+    (a: SortableNavigationItem, b: SortableNavigationItem) => number
+  >((val) => typeof val === "function"),
+});
+
+const NavigationMoveRuleSchema = z.object({
+  type: z.literal("move"),
+  match: z.string(),
+  to: z.string(),
+  position: z.enum(["before", "after"]),
+});
+
+export const NavigationRuleSchema = z.discriminatedUnion("type", [
+  NavigationModifyRuleSchema,
+  NavigationInsertRuleSchema,
+  NavigationRemoveRuleSchema,
+  NavigationSortRuleSchema,
+  NavigationMoveRuleSchema,
+]);
+
+export const NavigationRulesSchema = NavigationRuleSchema.array();
+
+export type NavigationRule = z.infer<typeof NavigationRuleSchema>;
+export type NavigationModifyRule = z.infer<typeof NavigationModifyRuleSchema>;
+export type NavigationInsertRule = z.infer<typeof NavigationInsertRuleSchema>;
+export type NavigationRemoveRule = z.infer<typeof NavigationRemoveRuleSchema>;
+export type NavigationSortRule = z.infer<typeof NavigationSortRuleSchema>;
+export type NavigationMoveRule = z.infer<typeof NavigationMoveRuleSchema>;
+
+const InputNavigationDocSchema = z.union([
+  z.string(),
+  z.object({
+    type: z.literal("doc"),
+    file: z.string(),
+    // Custom URL path for this document (overrides file-based path)
+    path: z.string().optional(),
+    icon: IconSchema.optional(),
+    label: z.string().optional(),
+    badge: BadgeSchema.optional(),
+    display: DisplaySchema,
+  }),
+]);
+
+const InputNavigationLinkSchema = z.object({
+  type: z.literal("link"),
+  to: z.string(),
+  label: z.string(),
+  target: z.enum(["_self", "_blank"]).optional(),
+  icon: IconSchema.optional(),
+  badge: BadgeSchema.optional(),
+  display: DisplaySchema,
+});
+
+const InputNavigationCustomPageSchema = z.object({
+  type: z.literal("custom-page"),
+  path: z.string(),
+  label: z.string().optional(),
+  element: z.any(),
+  icon: IconSchema.optional(),
+  badge: BadgeSchema.optional(),
+  display: DisplaySchema,
+  layout: z.enum(["default", "none"]).optional(),
+});
+
+const InputNavigationSeparatorSchema = z.object({
+  type: z.literal("separator"),
+  display: DisplaySchema,
+});
+
+const InputNavigationSectionSchema = z.object({
+  type: z.literal("section"),
+  label: z.string(),
+  display: DisplaySchema,
+});
+
+const InputNavigationFilterSchema = z.object({
+  type: z.literal("filter"),
+  placeholder: z.string().optional(),
+  display: DisplaySchema,
+});
+
+// Base category schema without items
+const BaseInputNavigationCategorySchema = z.object({
+  type: z.literal("category"),
+  icon: IconSchema.optional(),
+  label: z.string(),
+  collapsible: z.boolean().optional(),
+  collapsed: z.boolean().optional(),
+  link: InputNavigationCategoryLinkDocSchema.optional(),
+  display: DisplaySchema,
+});
+
+export type InputNavigationItem =
+  | z.infer<typeof InputNavigationDocSchema>
+  | z.infer<typeof InputNavigationLinkSchema>
+  | z.infer<typeof InputNavigationCustomPageSchema>
+  | z.infer<typeof InputNavigationSeparatorSchema>
+  | z.infer<typeof InputNavigationSectionSchema>
+  | z.infer<typeof InputNavigationFilterSchema>
+  | (z.infer<typeof BaseInputNavigationCategorySchema> & {
+      items: InputNavigationItem[];
+    });
+
+const InputNavigationCategorySchema: z.ZodType<
+  z.infer<typeof BaseInputNavigationCategorySchema> & {
+    items: InputNavigationItem[];
+  }
+> = BaseInputNavigationCategorySchema.extend({
+  items: z.lazy(() => InputNavigationItemSchema.array()),
+});
+
+const InputNavigationItemSchema: z.ZodType<InputNavigationItem> = z.union([
+  InputNavigationDocSchema,
+  InputNavigationLinkSchema,
+  InputNavigationCustomPageSchema,
+  InputNavigationSeparatorSchema,
+  InputNavigationSectionSchema,
+  InputNavigationFilterSchema,
+  InputNavigationCategorySchema,
+]);
+
+export const InputNavigationSchema = InputNavigationItemSchema.array();
+
+export type InputNavigationDoc = z.infer<typeof InputNavigationDocSchema>;
+export type InputNavigationLink = z.infer<typeof InputNavigationLinkSchema>;
+export type InputNavigationCustomPage = z.infer<
+  typeof InputNavigationCustomPageSchema
+>;
+export type InputNavigationSeparator = z.infer<
+  typeof InputNavigationSeparatorSchema
+>;
+export type InputNavigationSection = z.infer<
+  typeof InputNavigationSectionSchema
+>;
+export type InputNavigationFilter = z.infer<typeof InputNavigationFilterSchema>;
+export type InputNavigationCategory = z.infer<
+  typeof BaseInputNavigationCategorySchema
+> & { items: InputNavigationItem[] };
+export type InputNavigationCategoryLinkDoc = z.infer<
+  typeof InputNavigationCategoryLinkDocSchema
+>;
+
+export type InputNavigation = z.infer<typeof InputNavigationSchema>;

package/src/config/validators/ModulesSchema.ts

@@ -0,0 +1,312 @@
+import type { ComponentType, ReactNode } from "react";
+import { z } from "zod";
+
+const ModuleToggleSchema = z
+  .object({
+    enabled: z
+      .boolean()
+      .describe("Whether this module is active in the application."),
+  })
+  .partial();
+
+export const DocsModuleSchema = ModuleToggleSchema.extend({
+  files: z.union([z.string(), z.array(z.string())]).optional(),
+  publishMarkdown: z.boolean().optional(),
+  defaultOptions: z
+    .object({
+      toc: z.boolean(),
+      copyPage: z.boolean().optional(),
+      disablePager: z.boolean(),
+      showLastModified: z.boolean(),
+      suggestEdit: z
+        .object({
+          url: z.string(),
+          text: z.string().optional(),
+        })
+        .optional(),
+    })
+    .partial()
+    .optional(),
+  llms: z
+    .object({
+      llmsTxt: z.boolean().optional(),
+      llmsTxtFull: z.boolean().optional(),
+      includeProtected: z.boolean().optional(),
+    })
+    .optional(),
+});
+
+export const LandingLinkSchema = z.object({
+  label: z.string(),
+  href: z.string(),
+});
+
+export const LandingFeatureSchema = z.object({
+  title: z.string(),
+  description: z.string(),
+});
+
+export const LandingHeroSchema = z
+  .object({
+    title: z.string().optional(),
+    subtitle: z.string().optional(),
+    description: z.string().optional(),
+  })
+  .optional();
+
+export const LandingContentSchema = z
+  .object({
+    hero: LandingHeroSchema,
+    features: z.array(LandingFeatureSchema).optional(),
+    primaryAction: LandingLinkSchema.optional(),
+    secondaryAction: LandingLinkSchema.optional(),
+    showPoweredBy: z.boolean().optional(),
+  })
+  .optional();
+
+export const DashboardContentSchema = z
+  .object({
+    title: z.string().optional(),
+    subtitle: z.string().optional(),
+    description: z.string().optional(),
+    quickLinks: z.array(LandingLinkSchema).optional(),
+  })
+  .optional();
+
+export const ProfileContentSchema = z
+  .object({
+    title: z.string().optional(),
+    description: z.string().optional(),
+  })
+  .optional();
+
+export const PlanTierSchema = z.object({
+  name: z.string(),
+  price: z.string().optional(),
+  description: z.string().optional(),
+});
+
+export const PlansContentSchema = z
+  .object({
+    title: z.string().optional(),
+    description: z.string().optional(),
+    tiers: z.array(PlanTierSchema).optional(),
+  })
+  .optional();
+
+export const SubmodulePageFields = {
+  page: z
+    .string()
+    .optional()
+    .describe(
+      "Path to a custom page component file, relative to the project root.",
+    ),
+  component: z
+    .custom<ComponentType | ReactNode>()
+    .optional()
+    .describe("Custom React component for this sub-module page."),
+};
+
+export const LandingModuleSchema = ModuleToggleSchema.extend({
+  path: z.string().default("/").describe("Route path for the landing page."),
+  component: z
+    .custom<ComponentType | ReactNode>()
+    .optional()
+    .describe("Custom React component for the landing page."),
+  page: z
+    .string()
+    .optional()
+    .describe(
+      "Path to a custom landing page component file, relative to the project root.",
+    ),
+  layout: z
+    .enum(["default", "landing", "none"])
+    .default("landing")
+    .describe(
+      "Layout wrapper: landing (header + footer), default (docs layout), or none.",
+    ),
+  content: LandingContentSchema.describe(
+    "Default landing page content when no custom component is provided.",
+  ),
+});
+
+export const UserManagementModuleSchema = ModuleToggleSchema.extend({
+  routes: z
+    .object({
+      login: z.string().default("/signin"),
+      register: z.string().default("/signup"),
+      profile: z.string().default("profile"),
+      logout: z.string().default("/signout"),
+    })
+    .partial()
+    .optional(),
+  page: SubmodulePageFields.page,
+  component: SubmodulePageFields.component,
+  content: ProfileContentSchema.describe(
+    "Default profile page content when no custom component is provided.",
+  ),
+});
+
+export const ApiKeysModuleSchema = ModuleToggleSchema.extend({
+  path: z
+    .string()
+    .default("settings/api-keys")
+    .describe("Route path for API key management."),
+});
+
+export const PlansModuleSchema = ModuleToggleSchema.extend({
+  path: z
+    .string()
+    .default("plans")
+    .describe("Route path for plans and subscription management."),
+  page: SubmodulePageFields.page,
+  component: SubmodulePageFields.component,
+  content: PlansContentSchema.describe(
+    "Default plans page content when no custom component is provided.",
+  ),
+});
+
+export const DashboardModuleSchema = ModuleToggleSchema.extend({
+  path: z
+    .string()
+    .default("dashboard")
+    .describe("Route path for the user dashboard."),
+  page: SubmodulePageFields.page,
+  component: SubmodulePageFields.component,
+  content: DashboardContentSchema.describe(
+    "Default dashboard page content when no custom component is provided.",
+  ),
+});
+
+export const UserPanelModuleSchema = ModuleToggleSchema.extend({
+  basePath: z
+    .string()
+    .default("/account")
+    .describe("Base path prefix for user panel routes."),
+  dashboard: DashboardModuleSchema.optional(),
+  userManagement: UserManagementModuleSchema.optional(),
+  apiKeys: ApiKeysModuleSchema.optional(),
+  plans: PlansModuleSchema.optional(),
+});
+
+export const ModulesSchema = z
+  .object({
+    docs: DocsModuleSchema.optional().describe(
+      "Documentation module — MD/MDX pages and OpenAPI reference.",
+    ),
+    landing: LandingModuleSchema.optional().describe(
+      "Landing page module — marketing or home page.",
+    ),
+    userPanel: UserPanelModuleSchema.optional().describe(
+      "User panel module — authenticated user area with sub-modules.",
+    ),
+  })
+  .optional();
+
+export type DocsModuleConfig = z.infer<typeof DocsModuleSchema>;
+export type LandingModuleConfig = z.infer<typeof LandingModuleSchema>;
+export type UserManagementModuleConfig = z.infer<
+  typeof UserManagementModuleSchema
+>;
+export type ApiKeysModuleConfig = z.infer<typeof ApiKeysModuleSchema>;
+export type PlansModuleConfig = z.infer<typeof PlansModuleSchema>;
+export type DashboardModuleConfig = z.infer<typeof DashboardModuleSchema>;
+export type UserPanelModuleConfig = z.infer<typeof UserPanelModuleSchema>;
+export type ModulesConfig = z.infer<typeof ModulesSchema>;
+
+export type ResolvedDocsModule = {
+  enabled: boolean;
+  files?: string | string[];
+  publishMarkdown?: boolean;
+  defaultOptions?: DocsModuleConfig["defaultOptions"];
+  llms?: DocsModuleConfig["llms"];
+};
+
+export type LandingLinkConfig = z.infer<typeof LandingLinkSchema>;
+export type LandingFeatureConfig = z.infer<typeof LandingFeatureSchema>;
+export type LandingContentConfig = z.infer<typeof LandingContentSchema>;
+export type DashboardContentConfig = z.infer<typeof DashboardContentSchema>;
+export type ProfileContentConfig = z.infer<typeof ProfileContentSchema>;
+export type PlansContentConfig = z.infer<typeof PlansContentSchema>;
+export type PlanTierConfig = z.infer<typeof PlanTierSchema>;
+
+export type ResolvedLandingContent = {
+  hero?: {
+    title?: string;
+    subtitle?: string;
+    description?: string;
+  };
+  features?: LandingFeatureConfig[];
+  primaryAction?: LandingLinkConfig;
+  secondaryAction?: LandingLinkConfig;
+  showPoweredBy?: boolean;
+};
+
+export type ResolvedLandingModule = {
+  enabled: boolean;
+  path: string;
+  component?: ComponentType | ReactNode;
+  layout: "default" | "landing" | "none";
+  content: ResolvedLandingContent;
+};
+
+export type ResolvedDashboardContent = {
+  title?: string;
+  subtitle?: string;
+  description?: string;
+  quickLinks?: LandingLinkConfig[];
+};
+
+export type ResolvedProfileContent = {
+  title?: string;
+  description?: string;
+};
+
+export type ResolvedPlansContent = {
+  title?: string;
+  description?: string;
+  tiers?: PlanTierConfig[];
+};
+
+export type ResolvedUserManagementModule = {
+  enabled: boolean;
+  routes: {
+    login: string;
+    register: string;
+    profile: string;
+    logout: string;
+  };
+  content: ResolvedProfileContent;
+};
+
+export type ResolvedApiKeysModule = {
+  enabled: boolean;
+  path: string;
+};
+
+export type ResolvedPlansModule = {
+  enabled: boolean;
+  path: string;
+  content: ResolvedPlansContent;
+};
+
+export type ResolvedDashboardModule = {
+  enabled: boolean;
+  path: string;
+  content: ResolvedDashboardContent;
+};
+
+export type ResolvedUserPanelModule = {
+  enabled: boolean;
+  basePath: string;
+  dashboard: ResolvedDashboardModule;
+  userManagement: ResolvedUserManagementModule;
+  apiKeys: ResolvedApiKeysModule;
+  plans: ResolvedPlansModule;
+};
+
+export type ResolvedModulesConfig = {
+  docs: ResolvedDocsModule;
+  landing: ResolvedLandingModule;
+  userPanel: ResolvedUserPanelModule;
+};