@better-i18n/schemas 0.2.1 → 0.2.3

package/src/github.ts

@@ -0,0 +1,130 @@
+
+import { z } from 'zod';
+
+/**
+ * Schema for listing GitHub repositories from an installation.
+ */
+export const listRepositoriesSchema = z.object({
+  installationId: z.number(),
+  page: z.number().min(1).default(1),
+  limit: z.number().min(1).max(100).default(30),
+  type: z.enum(["all", "public", "private"]).default("all"),
+  sort: z
+    .enum(["created", "updated", "pushed", "full_name"])
+    .default("updated"),
+  direction: z.enum(["asc", "desc"]).default("desc"),
+});
+
+/**
+ * Schema for getting a specific GitHub repository.
+ */
+export const getRepositorySchema = z.object({
+  installationId: z.number(),
+  owner: z.string().min(1),
+  repo: z.string().min(1),
+});
+
+/**
+ * Schema for adding a GitHub repository to a project.
+ */
+export const addRepositorySchema = z.object({
+  projectId: z.string().uuid(),
+  installationId: z.number(),
+  owner: z.string().min(1),
+  repo: z.string().min(1),
+  path: z.string().default(""),
+  pattern: z.string().default(""),
+  format: z.enum(["JSON_FLAT", "JSON_NAMESPACED"]).default("JSON_FLAT"),
+  branch: z.string().optional(),
+  targetBranch: z.string().default("i18n-sync"),
+  autoPushToSourceBranch: z.boolean().default(false),
+});
+
+/**
+ * Schema for updating a GitHub repository.
+ */
+export const updateRepositorySchema = z.object({
+  repositoryId: z.string().uuid(),
+  path: z.string().optional(),
+  pattern: z.string().optional(),
+  format: z.enum(["JSON_FLAT", "JSON_NAMESPACED"]).optional(),
+  branch: z.string().optional(),
+  targetBranch: z.string().optional(),
+  enabled: z.boolean().optional(),
+  autoPushToSourceBranch: z.boolean().optional(),
+});
+
+/**
+ * Schema for removing a GitHub repository from a project.
+ */
+export const removeRepositorySchema = z.object({
+  repositoryId: z.string().uuid(),
+});
+
+/**
+ * Schema for syncing a GitHub repository.
+ */
+export const syncRepositorySchema = z.object({
+  repositoryId: z.string().uuid(),
+});
+
+/**
+ * Schema for GitHub OAuth callback.
+ */
+export const oauthCallbackSchema = z.object({
+  code: z.string().min(1),
+  state: z.string().optional(),
+  installation_id: z.string().optional(), // GitHub App installation ID (as string)
+});
+
+/**
+ * Schema for listing GitHub repository branches.
+ */
+export const listBranchesSchema = z.object({
+  installationId: z.number(),
+  owner: z.string().min(1),
+  repo: z.string().min(1),
+});
+
+/**
+ * Schema for getting GitHub repository tree.
+ */
+export const getTreeSchema = z.object({
+  installationId: z.number(),
+  owner: z.string().min(1),
+  repo: z.string().min(1),
+  branch: z.string().min(1),
+  path: z.string().default(""),
+});
+
+/**
+ * Schema for getting source files from a repository.
+ */
+export const getSourceFilesSchema = z.object({
+  repositoryId: z.string().uuid(),
+});
+
+/**
+ * Schema for connecting a GitHub repository for Doctor CI only (no sync).
+ */
+export const connectForDoctorSchema = z.object({
+  projectId: z.string().uuid(),
+  installationId: z.number(),
+  owner: z.string().min(1),
+  repo: z.string().min(1),
+});
+
+/**
+ * Types for GitHub repository operations.
+ */
+export type ListRepositoriesInput = z.infer<typeof listRepositoriesSchema>;
+export type GetRepositoryInput = z.infer<typeof getRepositorySchema>;
+export type AddRepositoryInput = z.infer<typeof addRepositorySchema>;
+export type UpdateRepositoryInput = z.infer<typeof updateRepositorySchema>;
+export type RemoveRepositoryInput = z.infer<typeof removeRepositorySchema>;
+export type SyncRepositoryInput = z.infer<typeof syncRepositorySchema>;
+export type OAuthCallbackInput = z.infer<typeof oauthCallbackSchema>;
+export type ListBranchesInput = z.infer<typeof listBranchesSchema>;
+export type GetTreeInput = z.infer<typeof getTreeSchema>;
+export type GetSourceFilesInput = z.infer<typeof getSourceFilesSchema>;
+export type ConnectForDoctorInput = z.infer<typeof connectForDoctorSchema>;

package/src/index.ts

@@ -0,0 +1,10 @@
+
+export * from "./ai-models";
+export * from "./github";
+export * from "./languages/index";
+export * from "./organizations/index";
+export * from "./projects/index";
+export * from "./subscription";
+export * from "./sync";
+export * from "./translations";
+export * from "./content";

package/src/languages/index.ts

@@ -0,0 +1,265 @@
+/**
+ * Language utilities and mappings
+ *
+ * Shared across the monorepo for consistent language handling.
+ */
+
+// Map common language codes to display names (ISO 639-1 and BCP 47 variants)
+export const LANGUAGE_NAMES: Record<string, string> = {
+  // BCP 47 locale variants
+  "zh-hans": "Chinese (Simplified)",
+  "zh-hant": "Chinese (Traditional)",
+  "pt-br": "Portuguese (Brazil)",
+  "pt-pt": "Portuguese (Portugal)",
+  "en-us": "English (US)",
+  "en-gb": "English (UK)",
+  "fr-ca": "French (Canada)",
+  "es-mx": "Spanish (Mexico)",
+  "es-419": "Spanish (Latin America)",
+  "sr-latn": "Serbian (Latin)",
+  "sr-cyrl": "Serbian (Cyrillic)",
+  "nb-no": "Norwegian Bokmål",
+  "nn-no": "Norwegian Nynorsk",
+  // ISO 639-1 base codes
+  en: "English",
+  tr: "Turkish",
+  de: "German",
+  fr: "French",
+  es: "Spanish",
+  it: "Italian",
+  pt: "Portuguese",
+  ru: "Russian",
+  zh: "Chinese",
+  ja: "Japanese",
+  ko: "Korean",
+  ar: "Arabic",
+  pl: "Polish",
+  nl: "Dutch",
+  sv: "Swedish",
+  no: "Norwegian",
+  da: "Danish",
+  fi: "Finnish",
+  cs: "Czech",
+  hu: "Hungarian",
+  ro: "Romanian",
+  uk: "Ukrainian",
+  vi: "Vietnamese",
+  th: "Thai",
+  id: "Indonesian",
+  ms: "Malay",
+  hi: "Hindi",
+  bn: "Bengali",
+  he: "Hebrew",
+  el: "Greek",
+  bg: "Bulgarian",
+  sk: "Slovak",
+  sl: "Slovenian",
+  hr: "Croatian",
+  sr: "Serbian",
+  lt: "Lithuanian",
+  lv: "Latvian",
+  et: "Estonian",
+  ca: "Catalan",
+  eu: "Basque",
+  gl: "Galician",
+  sq: "Albanian",
+  af: "Afrikaans",
+  ak: "Akan",
+  aa: "Afar",
+  ab: "Abkhazian",
+  am: "Amharic",
+  sw: "Swahili",
+  ta: "Tamil",
+  te: "Telugu",
+  ur: "Urdu",
+  fa: "Persian",
+  ml: "Malayalam",
+  mr: "Marathi",
+  gu: "Gujarati",
+  kn: "Kannada",
+  ne: "Nepali",
+  si: "Sinhala",
+  km: "Khmer",
+  lo: "Lao",
+  my: "Burmese",
+  ka: "Georgian",
+  hy: "Armenian",
+  az: "Azerbaijani",
+  uz: "Uzbek",
+  kk: "Kazakh",
+  mn: "Mongolian",
+  tl: "Filipino",
+  zu: "Zulu",
+  xh: "Xhosa",
+  ig: "Igbo",
+  yo: "Yoruba",
+  ha: "Hausa",
+  so: "Somali",
+};
+
+// Map common language codes to country codes for flags (ISO 639-1 and BCP 47 variants)
+export const LANGUAGE_TO_COUNTRY: Record<string, string> = {
+  // BCP 47 locale variants → country code
+  "zh-hans": "cn",
+  "zh-hant": "tw",
+  "pt-br": "br",
+  "pt-pt": "pt",
+  "en-us": "us",
+  "en-gb": "gb",
+  "fr-ca": "ca",
+  "es-mx": "mx",
+  "es-419": "mx",
+  "sr-latn": "rs",
+  "sr-cyrl": "rs",
+  "nb-no": "no",
+  "nn-no": "no",
+  // ISO 639-1 base codes
+  en: "gb",
+  tr: "tr",
+  de: "de",
+  fr: "fr",
+  es: "es",
+  it: "it",
+  pt: "pt",
+  ru: "ru",
+  zh: "cn",
+  ja: "jp",
+  ko: "kr",
+  ar: "sa",
+  pl: "pl",
+  nl: "nl",
+  sv: "se",
+  no: "no",
+  da: "dk",
+  fi: "fi",
+  cs: "cz",
+  hu: "hu",
+  ro: "ro",
+  uk: "ua",
+  vi: "vn",
+  th: "th",
+  id: "id",
+  ms: "my",
+  hi: "in",
+  bn: "bd",
+  he: "il",
+  el: "gr",
+  bg: "bg",
+  sk: "sk",
+  sl: "si",
+  hr: "hr",
+  sr: "rs",
+  lt: "lt",
+  lv: "lv",
+  et: "ee",
+  ca: "es-ct",
+  eu: "es-pv",
+  gl: "es-ga",
+  sq: "al",
+  af: "za",
+  ak: "gh",
+  aa: "et",
+  ab: "ge",
+  am: "et",
+  sw: "tz",
+  ta: "in",
+  te: "in",
+  ur: "pk",
+  fa: "ir",
+  ml: "in",
+  mr: "in",
+  gu: "in",
+  kn: "in",
+  ne: "np",
+  si: "lk",
+  km: "kh",
+  lo: "la",
+  my: "mm",
+  ka: "ge",
+  hy: "am",
+  az: "az",
+  uz: "uz",
+  kk: "kz",
+  mn: "mn",
+  tl: "ph",
+  zu: "za",
+  xh: "za",
+  ig: "ng",
+  yo: "ng",
+  ha: "ng",
+  so: "so",
+};
+
+/**
+ * Get country code from language code for flag mapping.
+ * Handles ISO 639-1 (e.g. "en") and BCP 47 (e.g. "zh-Hans", "pt-BR", "es-419").
+ * Returns undefined when we do not have a trustworthy mapping instead of
+ * guessing from the language code and accidentally showing the wrong flag.
+ */
+export function getCountryCode(langCode: string | undefined | null): string | undefined {
+  if (!langCode) return undefined;
+  const code = langCode.toLowerCase();
+  // 1. Exact match in table (zh-hans, pt-br, es-419, etc.)
+  if (LANGUAGE_TO_COUNTRY[code]) return LANGUAGE_TO_COUNTRY[code];
+  // 2. BCP 47 — parse subtag
+  if (code.includes("-")) {
+    const [base, subtag] = code.split("-");
+    // Region subtag (2 letters, e.g. "br" in pt-BR, "us" in en-US)
+    if (subtag.length === 2) return subtag;
+    // Script subtag (4 letters, e.g. "hans" in zh-Hans) or numeric region (e.g. "419")
+    // Fall back to base language country code
+    return LANGUAGE_TO_COUNTRY[base];
+  }
+  // 3. Base ISO 639-1
+  return LANGUAGE_TO_COUNTRY[code];
+}
+
+/**
+ * Get language name from code, with fallback to uppercase code.
+ * Supports ISO 639-1 and BCP 47 locale codes.
+ */
+export function getLanguageName(code: string): string {
+  const lower = code.toLowerCase();
+  if (LANGUAGE_NAMES[lower]) return LANGUAGE_NAMES[lower];
+  // BCP 47 fallback: if zh-Hans not found, try zh
+  if (lower.includes("-")) {
+    const base = lower.split("-")[0];
+    if (LANGUAGE_NAMES[base]) return LANGUAGE_NAMES[base];
+  }
+  return code.toUpperCase();
+}
+
+/**
+ * Format a language code for display following BCP 47 conventions.
+ * - Base codes: "en" → "EN"
+ * - Region subtag: "pt-br" → "pt-BR"
+ * - Script subtag: "zh-hans" → "zh-Hans"
+ * - Numeric region: "es-419" → "es-419"
+ */
+export function formatLanguageCode(code: string): string {
+  if (!code.includes("-")) return code.toUpperCase();
+  const [lang, subtag] = code.split("-");
+  // Region subtag (2 letters): pt-BR, en-US
+  if (subtag.length === 2)
+    return `${lang.toLowerCase()}-${subtag.toUpperCase()}`;
+  // Script subtag (4 letters): zh-Hans, sr-Latn
+  if (subtag.length === 4) {
+    return `${lang.toLowerCase()}-${subtag.charAt(0).toUpperCase()}${subtag.slice(1).toLowerCase()}`;
+  }
+  // Numeric or other: es-419
+  return `${lang.toLowerCase()}-${subtag}`;
+}
+
+/**
+ * Get language code from name (reverse lookup)
+ * Returns undefined if not found
+ */
+export function getLanguageCode(name: string): string | undefined {
+  const lowerName = name.toLowerCase();
+  for (const [code, langName] of Object.entries(LANGUAGE_NAMES)) {
+    if (langName.toLowerCase() === lowerName) {
+      return code;
+    }
+  }
+  return undefined;
+}

package/src/organizations/index.ts

@@ -0,0 +1,4 @@
+
+export * from "./organization.input";
+
+

package/src/organizations/organization.input.ts

@@ -0,0 +1,23 @@
+
+import { z } from 'zod';
+
+/**
+ * Schema for creating a new organization.
+ */
+export const createOrganizationSchema = z.object({
+  name: z
+    .string()
+    .min(1, "Organization name is required")
+    .max(100, "Organization name must be less than 100 characters"),
+  slug: z
+    .string()
+    .regex(/^[a-z0-9-]+$/, "Slug can only contain lowercase letters, numbers, and hyphens")
+    .min(1, "Slug is required")
+    .max(50, "Slug must be less than 50 characters"),
+  logo: z.string().url("Invalid logo URL").optional(),
+});
+
+// Type exports
+export type CreateOrganizationInput = z.infer<typeof createOrganizationSchema>;
+
+

package/src/projects/index.ts

@@ -0,0 +1,4 @@
+
+export * from "./project.input";
+
+

package/src/projects/project.input.ts

@@ -0,0 +1,221 @@
+
+import { z } from 'zod';
+
+/**
+ * Schema for creating a new project.
+ */
+export const createProjectSchema = z.object({
+  name: z.string().min(1, "Project name is required").max(100, "Project name must be less than 100 characters"),
+  slug: z
+    .string()
+    .regex(/^[a-z0-9-]+$/, "Slug can only contain lowercase letters, numbers, and hyphens")
+    .min(1, "Slug is required")
+    .max(50, "Slug must be less than 50 characters"),
+  sourceLanguage: z.string().min(2).max(10).describe("ISO 639-1 or BCP 47 language code"),
+  organizationId: z.string().uuid("Invalid organization ID"),
+});
+
+/**
+ * Schema for updating a project.
+ */
+export const updateProjectSchema = z.object({
+  projectId: z.string().uuid("Invalid project ID"),
+  name: z.string().min(1).max(100).optional(),
+  slug: z.string().regex(/^[a-z0-9-]+$/).optional(),
+  sourceLanguage: z.string().min(2).max(10).optional(),
+  autoTranslate: z.boolean().optional(),
+  autoPullRequest: z.boolean().optional(),
+  cdnFallbackEnabled: z.boolean().optional(),
+  cdnFallbackLanguageCode: z.string().min(2).max(10).optional().nullable(),
+  aiSystemPrompt: z.string().max(2000, "System prompt must be less than 2000 characters").optional().nullable(),
+  contentEnabled: z.boolean().optional(),
+  doctorReportRecipientId: z.string().uuid().optional().nullable(),
+});
+
+/**
+ * Schema for project list query.
+ */
+export const listProjectsSchema = z.object({
+  organizationId: z.string().uuid("Invalid organization ID"),
+  page: z.number().int().positive().default(1),
+  limit: z.number().int().positive().max(100).default(20),
+  search: z.string().optional(),
+});
+
+/**
+ * Schema for getting a project by ID.
+ */
+export const getProjectSchema = z.object({
+  projectId: z.string().uuid("Invalid project ID"),
+});
+
+/**
+ * Schema for getting a project by slug.
+ */
+export const getProjectBySlugSchema = z.object({
+  organizationId: z.string().uuid("Invalid organization ID"),
+  slug: z.string().regex(/^[a-z0-9-]+$/, "Invalid project slug"),
+});
+
+/**
+ * Schema for deleting a project.
+ */
+export const deleteProjectSchema = z.object({
+  projectId: z.string().uuid("Invalid project ID"),
+});
+
+/**
+ * Schema for adding a target language to a project.
+ * Status defaults to "active" for manual adds, but AI adds can specify "draft".
+ */
+export const addTargetLanguageSchema = z.object({
+  projectId: z.string().uuid("Invalid project ID"),
+  languageCode: z.string().min(2).max(10),
+  status: z.enum(["active", "draft"]).default("active").optional(),
+});
+
+/**
+ * Schema for batch adding multiple target languages to a project.
+ * Replaces sequential addTargetLanguage calls for better performance.
+ */
+export const batchAddTargetLanguagesSchema = z.object({
+  projectId: z.string().uuid("Invalid project ID"),
+  languageCodes: z
+    .array(z.string().min(2).max(10))
+    .min(1, "At least one language code required")
+    .max(50, "Maximum 50 languages at once"),
+  status: z.enum(["active", "draft"]).default("active").optional(),
+});
+
+/**
+ * Schema for batch updating target language statuses.
+ * Replaces sequential updateTargetLanguageStatus calls.
+ */
+export const batchUpdateTargetLanguageStatusSchema = z.object({
+  projectId: z.string().uuid("Invalid project ID"),
+  updates: z
+    .array(
+      z.object({
+        languageCode: z.string().min(2).max(10),
+        status: z.enum(["active", "draft", "archived"]),
+      }),
+    )
+    .min(1, "At least one update required")
+    .max(50, "Maximum 50 updates at once"),
+});
+
+/**
+ * Schema for removing a target language from a project.
+ */
+export const removeTargetLanguageSchema = z.object({
+  projectId: z.string().uuid("Invalid project ID"),
+  languageCode: z.string().min(2).max(10),
+});
+
+/**
+ * Language status for publish workflow:
+ * - "active": Visible in editor AND published to CDN
+ * - "draft": Visible in editor BUT excluded from CDN publish
+ * - "archived": Hidden from editor AND excluded from publish
+ */
+export const languageStatusEnum = z.enum(["active", "draft", "archived"]);
+
+/**
+ * Schema for updating a target language's status.
+ * Replaces the old boolean disabled field with a three-state enum.
+ */
+export const updateTargetLanguageStatusSchema = z.object({
+  projectId: z.string().uuid("Invalid project ID"),
+  languageCode: z.string().min(2).max(10),
+  status: languageStatusEnum,
+});
+
+/**
+ * Schema for reordering target languages within a project.
+ * Accepts an ordered array of language codes to set custom display order.
+ */
+export const reorderTargetLanguagesSchema = z.object({
+  projectId: z.string().uuid("Invalid project ID"),
+  languageCodes: z
+    .array(z.string().min(2).max(10))
+    .min(1, "At least one language code required"),
+  /** 0-based index of source language in the combined (source + target) list */
+  sourceLanguagePosition: z.number().int().min(0).optional(),
+});
+
+export type ReorderTargetLanguagesInput = z.infer<
+  typeof reorderTargetLanguagesSchema
+>;
+
+export const resetLanguageOrderSchema = z.object({
+  projectId: z.string().uuid("Invalid project ID"),
+});
+
+export type ResetLanguageOrderInput = z.infer<
+  typeof resetLanguageOrderSchema
+>;
+
+/**
+ * @deprecated Use updateTargetLanguageStatusSchema instead
+ * Kept for backward compatibility during migration
+ */
+export const toggleTargetLanguageSchema = z.object({
+  projectId: z.string().uuid("Invalid project ID"),
+  languageCode: z.string().min(2).max(10),
+  disabled: z.boolean(),
+});
+
+/**
+ * Schema for checking project slug availability within an organization.
+ */
+export const checkProjectSlugAvailabilitySchema = z.object({
+  organizationId: z.string().uuid("Invalid organization ID"),
+  slug: z.string().min(1).max(50).regex(/^[a-z0-9-]+$/, {
+    message: "Slug can only contain lowercase letters, numbers, and hyphens",
+  }),
+});
+
+/**
+ * Schema for getting project target languages.
+ */
+export const getTargetLanguagesSchema = z.object({
+  projectId: z.string().uuid("Invalid project ID"),
+});
+
+/**
+ * Schema for managing languages in a single operation.
+ * Combines batch add + batch status updates into one mutation
+ * so that a single activity record is created.
+ */
+export const manageLanguagesSchema = z.object({
+  projectId: z.string().uuid("Invalid project ID"),
+  add: z.array(z.string().min(2).max(10)).default([]),
+  statusUpdates: z
+    .array(
+      z.object({
+        languageCode: z.string().min(2).max(10),
+        status: z.enum(["active", "draft"]),
+      }),
+    )
+    .default([]),
+});
+
+export type ManageLanguagesInput = z.infer<typeof manageLanguagesSchema>;
+
+// Type exports
+export type CreateProjectInput = z.infer<typeof createProjectSchema>;
+export type UpdateProjectInput = z.infer<typeof updateProjectSchema>;
+export type ListProjectsInput = z.infer<typeof listProjectsSchema>;
+export type GetProjectInput = z.infer<typeof getProjectSchema>;
+export type GetProjectBySlugInput = z.infer<typeof getProjectBySlugSchema>;
+export type DeleteProjectInput = z.infer<typeof deleteProjectSchema>;
+export type AddTargetLanguageInput = z.infer<typeof addTargetLanguageSchema>;
+export type RemoveTargetLanguageInput = z.infer<typeof removeTargetLanguageSchema>;
+export type ToggleTargetLanguageInput = z.infer<typeof toggleTargetLanguageSchema>;
+export type UpdateTargetLanguageStatusInput = z.infer<typeof updateTargetLanguageStatusSchema>;
+export type LanguageStatus = z.infer<typeof languageStatusEnum>;
+export type GetTargetLanguagesInput = z.infer<typeof getTargetLanguagesSchema>;
+export type BatchAddTargetLanguagesInput = z.infer<typeof batchAddTargetLanguagesSchema>;
+export type BatchUpdateTargetLanguageStatusInput = z.infer<typeof batchUpdateTargetLanguageStatusSchema>;
+
+

package/src/subscription.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+
+export const invoiceSchema = z.object({
+  id: z.string(),
+  date: z.number(),
+  amount: z.number(),
+  status: z.enum(["draft", "open", "paid", "uncollectible", "void"]),
+  pdfUrl: z.string().nullable(),
+  hostedUrl: z.string().nullable(),
+});
+
+export type Invoice = z.infer<typeof invoiceSchema>;