@kyro-cms/admin 0.1.6 → 0.1.8

package/src/lib/i18n.tsx

@@ -0,0 +1,353 @@
+import { create } from "zustand";
+
+export const en = {
+  common: {
+    save: "Save",
+    cancel: "Cancel",
+    delete: "Delete",
+    edit: "Edit",
+    create: "Create",
+    add: "Add",
+    update: "Update",
+    confirm: "Confirm",
+    clear: "Clear",
+    close: "Close",
+    back: "Back",
+    next: "Next",
+    submit: "Submit",
+    remove: "Remove",
+    loading: "Loading...",
+  },
+
+  status: {
+    draft: "Draft",
+    published: "Published",
+    error: "Error",
+    success: "Success",
+    failed: "Failed",
+    archived: "Archived",
+  },
+
+  form: {
+    email: "Email",
+    password: "Password",
+    confirmPassword: "Confirm Password",
+    name: "Name",
+    label: "Label",
+    title: "Title",
+    description: "Description",
+    role: "Role",
+  },
+
+  placeholder: {
+    search: "Search...",
+    searchByNameOrEmail: "Search by name or email...",
+    searchFiles: "Search files...",
+    searchMedia: "Search media...",
+    searchTypes: "Search types...",
+    enterHeading: "Enter heading text...",
+    enterParagraph: "Enter paragraph text...",
+    enterMarkdown: "Enter markdown content...",
+    linkText: "Link text...",
+    url: "https://...",
+    value: "Value...",
+    videoUrl: "MP4 URL, YouTube, or Vimeo link...",
+    jsonPlaceholder: '{"key": "value"}',
+    folderName: "Folder name",
+    apiKey: "API Key",
+  },
+
+  tooltip: {
+    moveUp: "Move up",
+    moveDown: "Move down",
+    remove: "Remove",
+    edit: "Edit",
+    delete: "Delete",
+    livePreview: "Live Preview",
+    toggleSidebar: "Toggle Sidebar",
+    fullscreen: "Fullscreen",
+    exitFullscreen: "Exit fullscreen",
+    undo: "Undo",
+    redo: "Redo",
+    bold: "Bold",
+    italic: "Italic",
+    underline: "Underline",
+    strikethrough: "Strikethrough",
+    code: "Code",
+    link: "Link",
+    bulletList: "Bullet List",
+    numberedList: "Numbered List",
+    generateNewKey: "Generate new key",
+    copyToClipboard: "Copy to clipboard",
+  },
+
+  media: {
+    all: "All",
+    images: "Images",
+    videos: "Videos",
+    audio: "Audio",
+    documents: "Documents",
+    archives: "Archives",
+    noMediaFound: "No media files found",
+    deleteMedia: "Delete Media",
+    createFolder: "Create New Folder",
+    deleteFolder: "Delete Folder",
+    deleteSelected: "Delete Selected",
+    downloadCollection: "Download Collection",
+    editMetadata: "Edit metadata",
+    download: "Download",
+  },
+
+  user: {
+    teamManagement: "Team Management",
+    inviteMember: "Invite Member",
+    allUsers: "All Users",
+    admins: "Admins",
+    restricted: "Restricted",
+  },
+
+  auth: {
+    signIn: "Sign In",
+    createAccount: "Create Account",
+    signingIn: "Signing in...",
+    creatingAccount: "Creating account...",
+    dontHaveAccount: "Don't have an account?",
+    signUp: "Sign up",
+    alreadyHaveAccount: "Already have an account?",
+  },
+
+  confirm: {
+    deleteEntry: "Delete Entry",
+    deleteConfirm: "Delete {item}?",
+    actionCannotBeUndone: "This action cannot be undone.",
+    deleteDocuments: "Delete Documents",
+  },
+
+  audit: {
+    eventId: "Event ID",
+    timestamp: "Timestamp",
+    userEmail: "User Email",
+    userId: "User ID",
+    role: "Role",
+    resource: "Resource",
+    resourceId: "Resource ID",
+    ipAddress: "IP Address",
+  },
+
+  collection: {
+    pages: "Pages",
+    posts: "Posts",
+    categories: "Categories",
+    media: "Media",
+    settings: "Settings",
+    navigation: "Navigation",
+    users: "Users",
+  },
+
+  item: {
+    item: "Item",
+    itemCount: "Item {n}",
+    items: "Items",
+    noItems: 'No items. Click "Add Item" to create one.',
+  },
+
+  empty: {
+    noResults: "No results found",
+    loading: "Loading...",
+    noData: "No data available",
+  },
+
+  validation: {
+    required: "This field is required",
+    email: "Please enter a valid email address",
+    url: "Please enter a valid URL",
+    minLength: "Minimum {min} characters required",
+    maxLength: "Maximum {max} characters allowed",
+    number: "Please enter a valid number",
+    integer: "Please enter a whole number",
+    range: "Please enter a value between {min} and {max}",
+    json: "Please enter valid JSON",
+    hexColor: "Please enter a valid hex color",
+    phone: "Please enter a valid phone number",
+    postalCode: "Please enter a valid postal code",
+    matches: "Values do not match",
+    pattern: "Invalid format",
+  },
+
+  errors: {
+    generic: "Something went wrong. Please try again.",
+    network: "Network error. Please check your connection.",
+    unauthorized: "You are not authorized to perform this action.",
+    notFound: "The requested resource was not found.",
+    serverError: "Server error. Please try again later.",
+  },
+
+  actions: {
+    save: "Save",
+    cancel: "Cancel",
+    delete: "Delete",
+    edit: "Edit",
+    create: "Create",
+    add: "Add",
+    update: "Update",
+    confirm: "Confirm",
+    clear: "Clear",
+    close: "Close",
+    back: "Back",
+    next: "Next",
+    submit: "Submit",
+    remove: "Remove",
+    search: "Search",
+    filter: "Filter",
+    sort: "Sort",
+    refresh: "Refresh",
+    reload: "Reload",
+    export: "Export",
+    import: "Import",
+    upload: "Upload",
+    download: "Download",
+    copy: "Copy",
+    select: "Select",
+    selectAll: "Select All",
+    deselectAll: "Deselect All",
+  },
+
+  pagination: {
+    page: "Page",
+    of: "of",
+    first: "First",
+    last: "Last",
+    previous: "Previous",
+    next: "Next",
+    showing: "Showing",
+    to: "to",
+    from: "from",
+    results: "results",
+    perPage: "Per page",
+  },
+
+  filters: {
+    all: "All",
+    active: "Active",
+    inactive: "Inactive",
+    published: "Published",
+    draft: "Draft",
+    archived: "Archived",
+    search: "Search",
+    dateRange: "Date Range",
+    clearFilters: "Clear Filters",
+    applyFilters: "Apply Filters",
+  },
+
+  sort: {
+    ascending: "Ascending",
+    descending: "Descending",
+    sortBy: "Sort by",
+  },
+
+  table: {
+    noColumns: "No columns selected",
+    toggleColumns: "Toggle Columns",
+    rowsPerPage: "Rows per page",
+  },
+
+  blocks: {
+    addBlock: "Add Block",
+    removeBlock: "Remove Block",
+    moveUp: "Move Up",
+    moveDown: "Move Down",
+  },
+
+  richText: {
+    bold: "Bold",
+    italic: "Italic",
+    underline: "Underline",
+    strikethrough: "Strikethrough",
+    bulletList: "Bullet List",
+    numberedList: "Numbered List",
+    heading: "Heading",
+    link: "Link",
+    code: "Code",
+  },
+
+  upload: {
+    dragDrop: "Drag and drop files here",
+    orBrowse: "or browse",
+    uploading: "Uploading...",
+    uploadComplete: "Upload complete",
+    uploadFailed: "Upload failed",
+    fileTooLarge: "File is too large",
+    invalidType: "Invalid file type",
+  },
+
+  version: {
+    versionHistory: "Version History",
+    currentVersion: "Current Version",
+    restoreVersion: "Restore Version",
+    previewVersion: "Preview Version",
+    compareVersion: "Compare Versions",
+    autoSaved: "Auto-saved",
+    manuallySaved: "Manually saved",
+  },
+};
+
+type Translations = typeof en;
+
+interface I18nState {
+  locale: string;
+  translations: Translations;
+  setLocale: (locale: string) => void;
+}
+
+export const useI18n = create<I18nState>((set) => ({
+  locale: "en",
+  translations: en,
+  setLocale: (locale) => set({ locale }),
+}));
+
+export function getT(
+  key: string,
+  replacements?: Record<string, string>,
+): string {
+  const { translations } = useI18n.getState();
+  const keys = key.split(".");
+  let result: any = translations;
+
+  for (const k of keys) {
+    result = result?.[k];
+    if (result === undefined) return key;
+  }
+
+  if (typeof result !== "string") return key;
+
+  if (replacements) {
+    return Object.entries(replacements).reduce(
+      (str, [k, v]) => str.replace(new RegExp(`\\{${k}}`, "g"), v),
+      result,
+    );
+  }
+
+  return result;
+}
+
+export function useTranslation() {
+  const translations = useI18n((state) => state.translations);
+  return {
+    t: (key: string, replacements?: Record<string, string>) => {
+      const keys = key.split(".");
+      let result: any = translations;
+      for (const k of keys) {
+        result = result?.[k];
+        if (result === undefined) return key;
+      }
+      if (typeof result !== "string") return key;
+      if (replacements) {
+        return Object.entries(replacements).reduce(
+          (str, [k, v]) => str.replace(new RegExp(`\\{${k}}`, "g"), v),
+          result,
+        );
+      }
+      return result;
+    },
+  };
+}

package/src/lib/rate-limit.ts

@@ -0,0 +1,267 @@
+import Database from "better-sqlite3";
+import { randomBytes } from "crypto";
+
+const DB_PATH =
+  process.env.KYRO_AUTH_DB_PATH || process.env.KYRO_DB_PATH || "./data/auth.db";
+
+interface RateLimitConfig {
+  maxAttempts: number;
+  windowMs: number;
+  lockoutMs: number;
+}
+
+interface RateLimitResult {
+  allowed: boolean;
+  remaining: number;
+  resetAt: Date | null;
+  lockedUntil: Date | null;
+}
+
+const DEFAULT_CONFIG: RateLimitConfig = {
+  maxAttempts: 5,
+  windowMs: 15 * 60 * 1000, // 15 minutes
+  lockoutMs: 15 * 60 * 1000, // 15 minutes lockout
+};
+
+function getDb() {
+  return new Database(DB_PATH);
+}
+
+export async function checkRateLimit(
+  identifier: string,
+  action: string = "login",
+  config: RateLimitConfig = DEFAULT_CONFIG,
+): Promise<RateLimitResult> {
+  const db = getDb();
+  const now = new Date();
+
+  try {
+    // Clean up expired records first
+    db.prepare(
+      `
+      DELETE FROM rate_limits 
+      WHERE expires_at IS NOT NULL AND expires_at < ?
+    `,
+    ).run(now.toISOString());
+
+    // Get existing record
+    const existing = db
+      .prepare(
+        `
+      SELECT * FROM rate_limits 
+      WHERE identifier = ? AND action = ?
+    `,
+      )
+      .get(identifier, action) as any;
+
+    if (!existing) {
+      // First attempt - create record
+      const id = randomBytes(16).toString("hex");
+      db.prepare(
+        `
+        INSERT INTO rate_limits (id, identifier, action, attempts, first_attempt, last_attempt, created_at)
+        VALUES (?, ?, ?, 1, ?, ?, ?)
+      `,
+      ).run(
+        id,
+        identifier,
+        action,
+        now.toISOString(),
+        now.toISOString(),
+        now.toISOString(),
+      );
+
+      return {
+        allowed: true,
+        remaining: config.maxAttempts - 1,
+        resetAt: new Date(now.getTime() + config.windowMs),
+        lockedUntil: null,
+      };
+    }
+
+    // Check if currently locked
+    if (existing.expires_at && new Date(existing.expires_at) > now) {
+      return {
+        allowed: false,
+        remaining: 0,
+        resetAt: null,
+        lockedUntil: new Date(existing.expires_at),
+      };
+    }
+
+    // Check if within window
+    const firstAttempt = existing.first_attempt
+      ? new Date(existing.first_attempt)
+      : now;
+    const windowEnd = new Date(firstAttempt.getTime() + config.windowMs);
+
+    if (now > windowEnd) {
+      // Window expired - reset attempts
+      db.prepare(
+        `
+        UPDATE rate_limits 
+        SET attempts = 1, first_attempt = ?, last_attempt = ?, expires_at = NULL
+        WHERE identifier = ? AND action = ?
+      `,
+      ).run(now.toISOString(), now.toISOString(), identifier, action);
+
+      return {
+        allowed: true,
+        remaining: config.maxAttempts - 1,
+        resetAt: new Date(now.getTime() + config.windowMs),
+        lockedUntil: null,
+      };
+    }
+
+    // Within window - check attempts
+    const attempts = existing.attempts || 0;
+    const remaining = config.maxAttempts - attempts;
+
+    if (attempts >= config.maxAttempts) {
+      // Lock out the user
+      const lockUntil = new Date(now.getTime() + config.lockoutMs);
+      db.prepare(
+        `
+        UPDATE rate_limits 
+        SET last_attempt = ?, expires_at = ?
+        WHERE identifier = ? AND action = ?
+      `,
+      ).run(now.toISOString(), lockUntil.toISOString(), identifier, action);
+
+      return {
+        allowed: false,
+        remaining: 0,
+        resetAt: windowEnd,
+        lockedUntil: lockUntil,
+      };
+    }
+
+    // Increment attempts
+    db.prepare(
+      `
+      UPDATE rate_limits 
+      SET attempts = attempts + 1, last_attempt = ?
+      WHERE identifier = ? AND action = ?
+    `,
+    ).run(now.toISOString(), identifier, action);
+
+    return {
+      allowed: true,
+      remaining: remaining - 1,
+      resetAt: windowEnd,
+      lockedUntil: null,
+    };
+  } finally {
+    db.close();
+  }
+}
+
+export async function resetRateLimit(
+  identifier: string,
+  action: string = "login",
+): Promise<void> {
+  const db = getDb();
+
+  try {
+    db.prepare(
+      `
+      DELETE FROM rate_limits WHERE identifier = ? AND action = ?
+    `,
+    ).run(identifier, action);
+  } finally {
+    db.close();
+  }
+}
+
+export async function getAccountLockStatus(email: string): Promise<{
+  isLocked: boolean;
+  lockedUntil: Date | null;
+  failedAttempts: number;
+}> {
+  const db = getDb();
+
+  try {
+    const user = db
+      .prepare(
+        `
+      SELECT locked, locked_until, failed_login_attempts 
+      FROM users 
+      WHERE LOWER(email) = LOWER(?)
+    `,
+      )
+      .get(email) as any;
+
+    if (!user) {
+      return { isLocked: false, lockedUntil: null, failedAttempts: 0 };
+    }
+
+    const now = new Date();
+    const lockedUntil = user.locked_until ? new Date(user.locked_until) : null;
+    const isLocked = user.locked === 1 && (!lockedUntil || lockedUntil > now);
+
+    return {
+      isLocked,
+      lockedUntil: isLocked ? lockedUntil : null,
+      failedAttempts: user.failed_login_attempts || 0,
+    };
+  } finally {
+    db.close();
+  }
+}
+
+export async function recordFailedLogin(email: string): Promise<void> {
+  const db = getDb();
+
+  try {
+    const now = new Date();
+    const user = db
+      .prepare(
+        `
+      SELECT id FROM users WHERE LOWER(email) = LOWER(?)
+    `,
+      )
+      .get(email) as any;
+
+    if (!user) return;
+
+    // Increment failed attempts
+    db.prepare(
+      `
+      UPDATE users 
+      SET failed_login_attempts = COALESCE(failed_login_attempts, 0) + 1,
+          last_login = ?,
+          locked = CASE 
+            WHEN COALESCE(failed_login_attempts, 0) >= 4 THEN 1 
+            ELSE 0 
+          END,
+          locked_until = CASE 
+            WHEN COALESCE(failed_login_attempts, 0) >= 4 THEN ?
+            ELSE NULL 
+          END
+      WHERE id = ?
+    `,
+    ).run(
+      now.toISOString(),
+      new Date(now.getTime() + 15 * 60 * 1000).toISOString(),
+      user.id,
+    );
+  } finally {
+    db.close();
+  }
+}
+
+export async function unlockAccount(email: string): Promise<void> {
+  const db = getDb();
+
+  try {
+    db.prepare(
+      `
+      UPDATE users 
+      SET locked = 0, locked_until = NULL, failed_login_attempts = 0
+      WHERE LOWER(email) = LOWER(?)
+    `,
+    ).run(email);
+  } finally {
+    db.close();
+  }
+}

package/src/lib/slugify.ts

@@ -0,0 +1,15 @@
+/**
+ * Convert text to a URL-friendly slug.
+ */
+export function slugifyText(text: string): string {
+  if (!text) return "";
+  return text
+    .toString()
+    .toLowerCase()
+    .trim()
+    .replace(/\s+/g, "-")
+    .replace(/[^\w-]+/g, "")
+    .replace(/--+/g, "-")
+    .replace(/^-+/, "")
+    .replace(/-+$/, "");
+}