nextly 0.0.1 → 0.0.2-alpha.0

package/dist/chunk-APKKRD2G.mjs

@@ -0,0 +1,102 @@
+// src/utils/get-trusted-client-ip.ts
+var IPV4_RE = /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/;
+var IPV6_CHAR_RE = /^[0-9a-fA-F:.]+$/;
+function classifyIp(addr) {
+  if (IPV4_RE.test(addr)) return 4;
+  if (addr.includes(":") && IPV6_CHAR_RE.test(addr) && addr.length <= 45) {
+    return 6;
+  }
+  return 0;
+}
+function getTrustedClientIp(request, options) {
+  if (!options.trustProxy) {
+    return null;
+  }
+  const trustedCidrs = (options.trustedProxyIps ?? []).map(parseCidr).filter((c) => c !== null);
+  const xff = request.headers.get("x-forwarded-for");
+  if (xff) {
+    const hops = xff.split(",").map((h) => h.trim()).filter(Boolean);
+    for (let i = hops.length - 1; i >= 0; i--) {
+      const hop = stripIpv6Brackets(hops[i]);
+      if (!classifyIp(hop)) continue;
+      if (!isIpInAnyCidr(hop, trustedCidrs)) {
+        return hop;
+      }
+    }
+    return null;
+  }
+  const cfIp = request.headers.get("cf-connecting-ip")?.trim();
+  if (cfIp && classifyIp(cfIp)) {
+    return cfIp;
+  }
+  const realIp = request.headers.get("x-real-ip")?.trim();
+  if (realIp && classifyIp(realIp)) {
+    return realIp;
+  }
+  return null;
+}
+function parseTrustedProxyIpsEnv(raw) {
+  if (!raw) return [];
+  return raw.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function stripIpv6Brackets(ip) {
+  return ip.startsWith("[") && ip.endsWith("]") ? ip.slice(1, -1) : ip;
+}
+function parseCidr(entry) {
+  const [addr, prefixRaw] = entry.split("/");
+  const stripped = stripIpv6Brackets(addr);
+  const family = classifyIp(stripped);
+  if (family === 4) {
+    const prefix = prefixRaw === void 0 ? 32 : Number(prefixRaw);
+    if (!Number.isInteger(prefix) || prefix < 0 || prefix > 32) return null;
+    const intAddr = ipv4ToInt(stripped);
+    if (intAddr === null) return null;
+    const mask = prefix === 0 ? 0 : -1 >>> 32 - prefix << 32 - prefix;
+    return { family: "ipv4", network: intAddr & mask, prefix };
+  }
+  if (family === 6) {
+    if (prefixRaw !== void 0 && prefixRaw !== "128") return null;
+    return { family: "ipv6", network: stripped.toLowerCase(), prefix: 128 };
+  }
+  return null;
+}
+function ipv4ToInt(ip) {
+  const parts = ip.split(".");
+  if (parts.length !== 4) return null;
+  let acc = 0;
+  for (const p of parts) {
+    const n = Number(p);
+    if (!Number.isInteger(n) || n < 0 || n > 255) return null;
+    acc = acc << 8 | n;
+  }
+  return acc >>> 0;
+}
+function isIpInAnyCidr(ip, cidrs) {
+  if (cidrs.length === 0) return false;
+  const family = classifyIp(ip);
+  if (family === 4) {
+    const intIp = ipv4ToInt(ip);
+    if (intIp === null) return false;
+    for (const c of cidrs) {
+      if (c.family !== "ipv4") continue;
+      const mask = c.prefix === 0 ? 0 : -1 >>> 32 - c.prefix << 32 - c.prefix;
+      if ((intIp & mask) >>> 0 === (c.network & mask) >>> 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+  if (family === 6) {
+    const lower = ip.toLowerCase();
+    for (const c of cidrs) {
+      if (c.family === "ipv6" && c.network === lower) return true;
+    }
+    return false;
+  }
+  return false;
+}
+
+export {
+  getTrustedClientIp,
+  parseTrustedProxyIpsEnv
+};

package/dist/chunk-B2GV2BWH.mjs

@@ -0,0 +1,73 @@
+import {
+  seedPermissions
+} from "./chunk-UOP63Q54.mjs";
+import {
+  seedSuperAdmin
+} from "./chunk-PKMABBB5.mjs";
+
+// src/database/seeders/index.ts
+async function seedAll(adapter, options) {
+  const {
+    silent = false,
+    superAdminEmail,
+    superAdminPassword,
+    superAdminName,
+    skipSuperAdmin = false
+  } = options || {};
+  const log = silent ? () => {
+  } : console.log;
+  const errorLog = silent ? () => {
+  } : console.error;
+  log("\nRunning system bootstrap seeders...\n");
+  let totalCreated = 0;
+  let totalSkipped = 0;
+  let totalErrors = 0;
+  const allErrorMessages = [];
+  const permissionsResult = await seedPermissions(adapter, { silent });
+  totalCreated += permissionsResult.created;
+  totalSkipped += permissionsResult.skipped;
+  totalErrors += permissionsResult.errors;
+  if (permissionsResult.errorMessages) {
+    allErrorMessages.push(...permissionsResult.errorMessages);
+  }
+  if (!skipSuperAdmin) {
+    if (permissionsResult.success) {
+      const superAdminResult = await seedSuperAdmin(adapter, {
+        email: superAdminEmail,
+        password: superAdminPassword,
+        name: superAdminName,
+        silent
+      });
+      totalCreated += superAdminResult.created;
+      totalSkipped += superAdminResult.skipped;
+      totalErrors += superAdminResult.errors;
+      if (superAdminResult.errorMessages) {
+        allErrorMessages.push(...superAdminResult.errorMessages);
+      }
+    } else {
+      errorLog(
+        "\nSkipping super admin seeding due to permission seeding failures.\n"
+      );
+    }
+  } else {
+    log("\nSuper admin seeding skipped (skipSuperAdmin: true)\n");
+  }
+  const combinedResult = {
+    success: totalErrors === 0,
+    created: totalCreated,
+    skipped: totalSkipped,
+    errors: totalErrors,
+    total: totalCreated + totalSkipped + totalErrors,
+    errorMessages: allErrorMessages.length > 0 ? allErrorMessages : void 0
+  };
+  if (combinedResult.success) {
+    log("\nSystem bootstrap seeders completed.\n");
+  } else {
+    errorLog("\nSome seeders failed. Please check the errors above.\n");
+  }
+  return combinedResult;
+}
+
+export {
+  seedAll
+};

package/dist/chunk-D5HQBNUB.mjs

@@ -0,0 +1,74 @@
+// src/di/container.ts
+var Container = class _Container {
+  singletons = /* @__PURE__ */ new Map();
+  factories = /* @__PURE__ */ new Map();
+  parent;
+  constructor(parent) {
+    this.parent = parent;
+  }
+  /**
+   * Register a factory that creates a new instance each time get() is called.
+   */
+  register(name, factory) {
+    this.factories.set(name, factory);
+    return this;
+  }
+  /**
+   * Register a factory that creates a singleton instance (lazily initialized).
+   */
+  registerSingleton(name, factory) {
+    this.factories.set(name, () => {
+      if (!this.singletons.has(name)) {
+        this.singletons.set(name, factory());
+      }
+      return this.singletons.get(name);
+    });
+    return this;
+  }
+  /**
+   * Get a service by name. Throws if not registered.
+   */
+  get(name) {
+    const factory = this.factories.get(name);
+    if (factory) {
+      return factory();
+    }
+    if (this.parent) {
+      return this.parent.get(name);
+    }
+    if (process.env.NODE_ENV === "development") {
+      const registered = Array.from(this.factories.keys());
+      const registeredList = registered.length > 0 ? registered.join(", ") : "(none)";
+      throw new Error(
+        `Service "${name}" is not registered in container. Registered services: ${registeredList}`
+      );
+    }
+    throw new Error(`Service "${name}" is not registered in container`);
+  }
+  /**
+   * Check if a service is registered.
+   */
+  has(name) {
+    return this.factories.has(name) || (this.parent?.has(name) ?? false);
+  }
+  /**
+   * Create a child scope container for request-scoped services.
+   */
+  createScope() {
+    return new _Container(this);
+  }
+  /**
+   * Clear all registrations and singletons (useful for testing).
+   */
+  clear() {
+    this.singletons.clear();
+    this.factories.clear();
+  }
+};
+var globalForNextly = globalThis;
+var container = globalForNextly.__nextly_container ??= new Container();
+
+export {
+  Container,
+  container
+};

package/dist/chunk-DNNG377Z.mjs

@@ -0,0 +1,204 @@
+// src/domains/schema/services/field-column-descriptor.ts
+var LAYOUT_FIELD_TYPES = /* @__PURE__ */ new Set(["tabs", "collapsible", "row"]);
+function toSnakeCase(name) {
+  return name.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+function getColumnDescriptor(field, dialect) {
+  if (LAYOUT_FIELD_TYPES.has(field.type)) return null;
+  const name = toSnakeCase(field.name);
+  const kind = classifyFieldKind(field);
+  const nullable = kind === "fkSingle" ? true : field.required !== true;
+  if (kind === "skip") return null;
+  const dialectType = renderDialectType(
+    kind,
+    dialect,
+    /* length */
+    void 0
+  );
+  const length = lengthForKind(kind);
+  return {
+    name,
+    dialectType,
+    ...length !== void 0 ? { length } : {},
+    nullable,
+    kind
+  };
+}
+function classifyFieldKind(field) {
+  switch (field.type) {
+    case "text":
+    case "email":
+    case "password":
+    case "slug":
+    case "select":
+    case "radio":
+      return "text";
+    case "textarea":
+    case "richText":
+    case "code":
+      return "longText";
+    case "number": {
+      const fmt = field.options?.format;
+      return fmt === "float" ? "double" : "integer";
+    }
+    case "checkbox":
+      return "boolean";
+    case "date":
+      return "timestamp";
+    case "relationship":
+    case "upload": {
+      const hasMany = field.hasMany;
+      const relationTo = field.relationTo;
+      if (hasMany || Array.isArray(relationTo)) return "json";
+      return "fkSingle";
+    }
+    case "repeater":
+    case "group":
+    case "blocks":
+    case "component":
+    case "json":
+    case "chips":
+      return "json";
+    case "point":
+      return "json";
+    default:
+      return "text";
+  }
+}
+function renderDialectType(kind, dialect, length) {
+  if (kind === "text") {
+    if (dialect === "postgresql") return "text";
+    if (dialect === "mysql") return `varchar(${length ?? 255})`;
+    return "text";
+  }
+  if (kind === "longText") {
+    if (dialect === "postgresql") return "text";
+    if (dialect === "mysql") return "text";
+    return "text";
+  }
+  if (kind === "varchar") {
+    if (dialect === "postgresql") return "text";
+    if (dialect === "mysql") return `varchar(${length ?? 255})`;
+    return "text";
+  }
+  if (kind === "boolean") {
+    if (dialect === "postgresql") return "bool";
+    if (dialect === "mysql") return "tinyint(1)";
+    return "integer";
+  }
+  if (kind === "integer") {
+    if (dialect === "postgresql") return "int4";
+    if (dialect === "mysql") return "int";
+    return "integer";
+  }
+  if (kind === "double") {
+    if (dialect === "postgresql") return "float8";
+    if (dialect === "mysql") return "double";
+    return "real";
+  }
+  if (kind === "timestamp") {
+    if (dialect === "postgresql") return "timestamp";
+    if (dialect === "mysql") return "timestamp";
+    return "integer";
+  }
+  if (kind === "json") {
+    if (dialect === "postgresql") return "jsonb";
+    if (dialect === "mysql") return "json";
+    return "text";
+  }
+  if (kind === "fkSingle") {
+    if (dialect === "postgresql") return "text";
+    if (dialect === "mysql") return "varchar(36)";
+    return "text";
+  }
+  return "text";
+}
+function lengthForKind(kind) {
+  if (kind === "text") return 255;
+  if (kind === "varchar") return 255;
+  if (kind === "fkSingle") return 36;
+  return void 0;
+}
+function getSystemColumnDescriptors(dialect, opts) {
+  const cols = [];
+  if (dialect === "postgresql") {
+    cols.push({ name: "id", dialectType: "text", nullable: false, primaryKey: true });
+    if (!opts.hasTitleField) {
+      cols.push({ name: "title", dialectType: "text", nullable: false, primaryKey: false });
+    }
+    if (!opts.hasSlugField) {
+      cols.push({ name: "slug", dialectType: "text", nullable: false, primaryKey: false });
+    }
+    cols.push({ name: "created_at", dialectType: "timestamp", nullable: true, primaryKey: false });
+    cols.push({ name: "updated_at", dialectType: "timestamp", nullable: true, primaryKey: false });
+    if (opts.hasStatus) {
+      cols.push({ name: "status", dialectType: "text", nullable: false, primaryKey: false });
+    }
+  } else if (dialect === "mysql") {
+    cols.push({
+      name: "id",
+      dialectType: "varchar(36)",
+      length: 36,
+      nullable: false,
+      primaryKey: true
+    });
+    if (!opts.hasTitleField) {
+      cols.push({
+        name: "title",
+        dialectType: "varchar(255)",
+        length: 255,
+        nullable: false,
+        primaryKey: false
+      });
+    }
+    if (!opts.hasSlugField) {
+      cols.push({
+        name: "slug",
+        dialectType: "varchar(255)",
+        length: 255,
+        nullable: false,
+        primaryKey: false
+      });
+    }
+    cols.push({
+      name: "created_at",
+      dialectType: "timestamp",
+      nullable: true,
+      primaryKey: false
+    });
+    cols.push({
+      name: "updated_at",
+      dialectType: "timestamp",
+      nullable: true,
+      primaryKey: false
+    });
+    if (opts.hasStatus) {
+      cols.push({
+        name: "status",
+        dialectType: "varchar(20)",
+        length: 20,
+        nullable: false,
+        primaryKey: false
+      });
+    }
+  } else {
+    cols.push({ name: "id", dialectType: "text", nullable: false, primaryKey: true });
+    if (!opts.hasTitleField) {
+      cols.push({ name: "title", dialectType: "text", nullable: false, primaryKey: false });
+    }
+    if (!opts.hasSlugField) {
+      cols.push({ name: "slug", dialectType: "text", nullable: false, primaryKey: false });
+    }
+    cols.push({ name: "created_at", dialectType: "integer", nullable: true, primaryKey: false });
+    cols.push({ name: "updated_at", dialectType: "integer", nullable: true, primaryKey: false });
+    if (opts.hasStatus) {
+      cols.push({ name: "status", dialectType: "text", nullable: false, primaryKey: false });
+    }
+  }
+  return cols;
+}
+
+export {
+  getColumnDescriptor,
+  getSystemColumnDescriptors
+};

package/dist/chunk-DP3G27G5.mjs

@@ -0,0 +1,135 @@
+import {
+  env
+} from "./chunk-UJ2IMJ4W.mjs";
+
+// src/database/factory.ts
+async function createAdapter(config) {
+  const type = config?.type ?? detectAdapterType();
+  const url = config?.url ?? env.DATABASE_URL;
+  if (!url && type !== "sqlite") {
+    throw new Error(
+      "DATABASE_URL environment variable is required for PostgreSQL and MySQL"
+    );
+  }
+  const adapterConfig = { ...config, url };
+  if (type !== "postgresql" && type !== "mysql" && type !== "sqlite") {
+    const unknownType = String(type);
+    throw new Error(`Unsupported database type: ${unknownType}`);
+  }
+  const pkgName = type === "postgresql" ? "@nextlyhq/adapter-postgres" : type === "mysql" ? "@nextlyhq/adapter-mysql" : "@nextlyhq/adapter-sqlite";
+  let adapter;
+  try {
+    if (type === "postgresql") {
+      const mod = await import("@nextlyhq/adapter-postgres");
+      adapter = mod.createPostgresAdapter(adapterConfig);
+    } else if (type === "mysql") {
+      const mod = await import("@nextlyhq/adapter-mysql");
+      adapter = mod.createMySqlAdapter(adapterConfig);
+    } else {
+      const mod = await import("@nextlyhq/adapter-sqlite");
+      const sqliteConfig = {
+        ...adapterConfig,
+        url: url ?? "file:./data/nextly.db"
+      };
+      adapter = mod.createSqliteAdapter(sqliteConfig);
+    }
+  } catch (error) {
+    throw new Error(
+      `Failed to load database adapter for "${type}". Make sure ${pkgName} is installed:
+
+  npm install ${pkgName}
+
+Original error: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  await adapter.connect();
+  return adapter;
+}
+async function createAdapterFromEnv() {
+  return createAdapter();
+}
+function detectAdapterType() {
+  const dialect = env.DB_DIALECT;
+  if (dialect) {
+    switch (dialect) {
+      case "postgresql":
+        return "postgresql";
+      case "mysql":
+        return "mysql";
+      case "sqlite":
+        return "sqlite";
+      default:
+        throw new Error(
+          `Unknown DB_DIALECT: ${String(dialect)}. Must be "postgresql", "mysql", or "sqlite"`
+        );
+    }
+  }
+  const url = env.DATABASE_URL;
+  if (url) {
+    if (url.startsWith("postgres://") || url.startsWith("postgresql://")) {
+      return "postgresql";
+    }
+    if (url.startsWith("mysql://")) {
+      return "mysql";
+    }
+    if (url.startsWith("file:") || url.endsWith(".db") || url.endsWith(".sqlite")) {
+      return "sqlite";
+    }
+  }
+  console.warn(
+    "\u26A0\uFE0F  No DB_DIALECT or DATABASE_URL specified, defaulting to PostgreSQL. Set DB_DIALECT environment variable to avoid this warning."
+  );
+  return "postgresql";
+}
+function validateDatabaseEnv() {
+  const errors = [];
+  const dialect = env.DB_DIALECT;
+  const url = env.DATABASE_URL;
+  if (!dialect && !url) {
+    errors.push(
+      "Either DB_DIALECT or DATABASE_URL must be set. Set DB_DIALECT to 'postgresql', 'mysql', or 'sqlite'."
+    );
+  }
+  if (dialect && !["postgresql", "mysql", "sqlite"].includes(dialect)) {
+    errors.push(
+      `Invalid DB_DIALECT: "${dialect}". Must be "postgresql", "mysql", or "sqlite".`
+    );
+  }
+  if (dialect && dialect !== "sqlite" && !url) {
+    errors.push(
+      `DATABASE_URL is required for ${dialect}. Please set DATABASE_URL environment variable with your connection string.`
+    );
+  }
+  return { valid: errors.length === 0, errors };
+}
+async function checkAdapterHealth(adapter) {
+  try {
+    const connected = adapter.isConnected();
+    if (!connected) {
+      await adapter.connect();
+    }
+    const capabilities = adapter.getCapabilities();
+    await adapter.executeQuery("SELECT 1 as test");
+    const poolStats = adapter.getPoolStats();
+    return {
+      healthy: true,
+      dialect: capabilities.dialect,
+      connected: adapter.isConnected(),
+      poolStats
+    };
+  } catch (error) {
+    return {
+      healthy: false,
+      dialect: adapter.getCapabilities().dialect,
+      connected: adapter.isConnected(),
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+export {
+  createAdapter,
+  createAdapterFromEnv,
+  validateDatabaseEnv,
+  checkAdapterHealth
+};

package/dist/chunk-DXGGXIUZ.mjs

@@ -0,0 +1,57 @@
+// src/auth/middleware/rate-limiter.ts
+var RateLimiter = class {
+  /**
+   * Internal store: keyId → sorted array of allowed request timestamps (ms).
+   * Arrays are bounded at `limit` entries per key.
+   */
+  windows = /* @__PURE__ */ new Map();
+  /**
+   * Check whether a request for `keyId` is allowed under the given rate limit.
+   *
+   * @param keyId   - The API key ID (used as the map key — NOT the raw key string).
+   * @param limit   - Maximum number of requests allowed within `windowMs`.
+   * @param windowMs - Sliding window size in milliseconds (e.g. 3_600_000 for 1 hour).
+   * @returns `{ allowed, remaining, resetAt }`
+   */
+  check(keyId, limit, windowMs) {
+    const now = Date.now();
+    const windowStart = now - windowMs;
+    let timestamps = this.windows.get(keyId) ?? [];
+    timestamps = timestamps.filter((t) => t > windowStart);
+    const count = timestamps.length;
+    const allowed = count < limit;
+    if (allowed) {
+      timestamps.push(now);
+      this.windows.set(keyId, timestamps);
+    }
+    const remaining = Math.max(0, limit - timestamps.length);
+    const oldestInWindow = timestamps[0];
+    const resetAt = new Date(
+      oldestInWindow !== void 0 ? oldestInWindow + windowMs : now + windowMs
+    );
+    return { allowed, remaining, resetAt };
+  }
+  /**
+   * Remove all state for a given key.
+   *
+   * Useful for tests or if a key is revoked and its slot should be freed
+   * immediately rather than waiting for natural expiry.
+   *
+   * @param keyId - The API key ID whose window should be cleared.
+   */
+  clear(keyId) {
+    this.windows.delete(keyId);
+  }
+  /**
+   * Return the number of keys currently tracked.
+   * Intended for testing and monitoring only.
+   */
+  get size() {
+    return this.windows.size;
+  }
+};
+var rateLimiter = new RateLimiter();
+
+export {
+  rateLimiter
+};