nextly 0.0.1 → 0.0.2-alpha.1

package/dist/chunk-2W3DVD7S.mjs

@@ -0,0 +1,647 @@
+import {
+  getDialectTables
+} from "./chunk-TS7GHTG2.mjs";
+import {
+  container
+} from "./chunk-D5HQBNUB.mjs";
+
+// src/shared/lib/date-formatting.ts
+var ISO_DATE_TIME_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?(?:Z|[+-]\d{2}:\d{2})?$/;
+var MYSQL_DATE_TIME_REGEX = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d{1,3})?$/;
+var HAS_EXPLICIT_TIMEZONE_REGEX = /(?:Z|[+-]\d{2}:\d{2})$/i;
+var TIMESTAMP_KEY_REGEX = /(?:^|_)(createdAt|updatedAt|created_at|updated_at|publishedAt|published_at|deletedAt|deleted_at|lastLoginAt|last_login_at|expires|expiresAt|expires_at|date|time|timestamp|at|on)$/i;
+function shouldDebugTimezone() {
+  return process.env.NEXTLY_DEBUG_TIMEZONE === "1";
+}
+function debugTimezone(stage, details) {
+  if (!shouldDebugTimezone()) return;
+  console.debug(`[timezone][${stage}]`, details);
+}
+function isTimestampFieldKey(key) {
+  if (!key) return false;
+  return TIMESTAMP_KEY_REGEX.test(key);
+}
+function formatIsoWithTimezone(date, timezone) {
+  try {
+    const formatter = new Intl.DateTimeFormat("en-US", {
+      timeZone: timezone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      fractionalSecondDigits: 3,
+      hourCycle: "h23"
+    });
+    const parts = formatter.formatToParts(date);
+    const map = {};
+    parts.forEach((p) => {
+      map[p.type] = p.value;
+    });
+    const year = map.year || date.getFullYear().toString();
+    const month = map.month || (date.getMonth() + 1).toString().padStart(2, "0");
+    const day = map.day || date.getDate().toString().padStart(2, "0");
+    const hour = map.hour || date.getHours().toString().padStart(2, "0");
+    const minute = map.minute || date.getMinutes().toString().padStart(2, "0");
+    const second = map.second || date.getSeconds().toString().padStart(2, "0");
+    const fractionalSecond = map.fractionalSecond || "000";
+    const isoNoOffset = `${year}-${month}-${day}T${hour}:${minute}:${second}.${fractionalSecond}`;
+    const offsetFormatter = new Intl.DateTimeFormat("en-US", {
+      timeZone: timezone,
+      timeZoneName: "longOffset"
+    });
+    const offsetPart = offsetFormatter.formatToParts(date).find((p) => p.type === "timeZoneName")?.value || "GMT";
+    let formattedOffset = offsetPart.replace("GMT", "").trim();
+    if (!formattedOffset || formattedOffset === "Z") return `${isoNoOffset}Z`;
+    if (!formattedOffset.includes(":")) {
+      const sign = formattedOffset[0];
+      const hours = formattedOffset.substring(1).padStart(2, "0");
+      formattedOffset = `${sign}${hours}:00`;
+    }
+    return `${isoNoOffset}${formattedOffset}`;
+  } catch (_error) {
+    return date.toISOString();
+  }
+}
+function normalizeTimestampString(value, timezone) {
+  if (!ISO_DATE_TIME_REGEX.test(value) && !MYSQL_DATE_TIME_REGEX.test(value)) {
+    return value;
+  }
+  const hasExplicitTimezone = HAS_EXPLICIT_TIMEZONE_REGEX.test(value);
+  const normalizedInput = MYSQL_DATE_TIME_REGEX.test(value) ? value.replace(" ", "T") : value;
+  const parseInput = hasExplicitTimezone ? normalizedInput : `${normalizedInput}Z`;
+  const parsed = new Date(parseInput);
+  if (Number.isNaN(parsed.getTime())) {
+    debugTimezone("parse-failed", {
+      raw: value,
+      parseInput,
+      reason: "Invalid Date"
+    });
+    return value;
+  }
+  if (timezone) {
+    const localized = formatIsoWithTimezone(parsed, timezone);
+    debugTimezone("localized", {
+      raw: value,
+      timezone,
+      localized
+    });
+    return localized;
+  }
+  const normalized = parsed.toISOString();
+  debugTimezone("normalized", {
+    raw: value,
+    parseInput,
+    normalized,
+    hasExplicitTimezone
+  });
+  return normalized;
+}
+function normalizeDbTimestamp(value) {
+  if (value == null) return null;
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) return null;
+    const utcDate = new Date(
+      Date.UTC(
+        value.getFullYear(),
+        value.getMonth(),
+        value.getDate(),
+        value.getHours(),
+        value.getMinutes(),
+        value.getSeconds(),
+        value.getMilliseconds()
+      )
+    );
+    return utcDate.toISOString();
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (/^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(trimmed)) {
+      const normalized = trimmed.replace(" ", "T");
+      return `${normalized}Z`;
+    }
+    const d = new Date(trimmed);
+    if (!Number.isNaN(d.getTime())) {
+      return d.toISOString();
+    }
+  }
+  return String(value);
+}
+function normalizeTimestampsInPayload(value, timezone, currentKey) {
+  if (typeof value === "string") {
+    const isKnownDateKey = isTimestampFieldKey(currentKey);
+    const looksLikeDateValue = ISO_DATE_TIME_REGEX.test(value) || MYSQL_DATE_TIME_REGEX.test(value);
+    if (isKnownDateKey || looksLikeDateValue) {
+      return normalizeTimestampString(value, timezone);
+    }
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => normalizeTimestampsInPayload(item, timezone));
+  }
+  if (value && typeof value === "object") {
+    const input = value;
+    const output = {};
+    for (const [key, nested] of Object.entries(input)) {
+      output[key] = normalizeTimestampsInPayload(nested, timezone, key);
+    }
+    return output;
+  }
+  return value;
+}
+async function withTimezoneFormatting(response) {
+  const contentType = response.headers.get("content-type") || "";
+  if (!contentType.toLowerCase().includes("application/json")) {
+    return response;
+  }
+  if (response.status >= 400) {
+    return response;
+  }
+  let parsed;
+  try {
+    parsed = await response.clone().json();
+  } catch {
+    return response;
+  }
+  let timezone = null;
+  try {
+    if (container.has("generalSettingsService")) {
+      const svc = container.get(
+        "generalSettingsService"
+      );
+      timezone = await svc.getTimezone();
+    }
+  } catch (_err) {
+  }
+  const activeTimezone = timezone ?? null;
+  const transformed = normalizeTimestampsInPayload(parsed, activeTimezone);
+  const headers = new Headers(response.headers);
+  headers.set("Content-Type", "application/json");
+  return new Response(JSON.stringify(transformed), {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+
+// src/shared/base-service.ts
+import { sql } from "drizzle-orm";
+var sqliteBeginImmediate = sql.raw("BEGIN IMMEDIATE");
+var sqliteCommit = sql.raw("COMMIT");
+var sqliteRollback = sql.raw("ROLLBACK");
+var BaseService = class {
+  constructor(adapter, logger) {
+    this.adapter = adapter;
+    this.logger = logger;
+  }
+  _db = null;
+  _tables = null;
+  /**
+   * Raw Drizzle instance for relational queries (.query.TABLE.findFirst(), etc.).
+   * Prefer this.adapter methods for simple CRUD; use this.db only when you need
+   * Drizzle's query builder directly (JOINs, relational queries, aggregations).
+   *
+   * Schema is passed to getDrizzle() so that the relational query API
+   * (db.query.users.findFirst, etc.) has access to table definitions.
+   * Cached after first access.
+   */
+  get db() {
+    if (!this._db) {
+      this._db = this.adapter.getDrizzle(
+        this.tables
+      );
+    }
+    return this._db;
+  }
+  /**
+   * Dialect-specific table schemas resolved from the current adapter.
+   * Cached after first access.
+   */
+  get tables() {
+    if (!this._tables) {
+      this._tables = getDialectTables(
+        this.adapter.getCapabilities().dialect
+      );
+    }
+    return this._tables;
+  }
+  /**
+   * Get the current database dialect.
+   *
+   * Use this property for conditional logic when you need database-specific behavior.
+   * However, prefer using the adapter's built-in dialect handling when possible.
+   *
+   * @returns The database dialect: 'postgresql', 'mysql', or 'sqlite'
+   *
+   * @example
+   * ```typescript
+   * // Check dialect for conditional logic
+   * if (this.dialect === 'postgresql') {
+   *   // Use PostgreSQL-specific optimization
+   *   await this.adapter.execute('SELECT ... FOR UPDATE SKIP LOCKED');
+   * } else {
+   *   // Fallback for other databases
+   *   await this.adapter.select('users', { where: ... });
+   * }
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Log dialect for debugging
+   * this.logger.info(`Running query on ${this.dialect} database`);
+   * ```
+   */
+  get dialect() {
+    return this.adapter.getCapabilities().dialect;
+  }
+  /**
+   * Execute work within a database transaction using Drizzle ORM's fluent API.
+   *
+   * Transactions ensure ACID properties (Atomicity, Consistency, Isolation, Durability)
+   * across multiple database operations. If the callback throws, all changes are rolled
+   * back. If it returns, the transaction commits.
+   *
+   * The `tx` argument is a Drizzle instance that exposes the fluent query API
+   * (`tx.insert(table).values(data)`, `tx.update(table).set(data).where(cond)`, etc.).
+   * On PostgreSQL and MySQL this is a dialect-specific Drizzle transaction object
+   * (`NodePgTransaction` / `MySql2Transaction`). On SQLite it is the shared `this.db`
+   * instance, because better-sqlite3's native transaction API cannot run async callbacks
+   * — see the SQLite branch below for why.
+   *
+   * ## Transaction Behavior by Dialect
+   *
+   * - **PostgreSQL** — routes through Drizzle's native `db.transaction(fn)`. Supports
+   *   savepoints, isolation levels, and fully async callbacks. tx is a real
+   *   `NodePgTransaction`.
+   * - **MySQL** — same as PostgreSQL via `MySql2Transaction`.
+   * - **SQLite** — better-sqlite3's `db.transaction()` rejects any callback that returns
+   *   a promise (`TypeError: Transaction function cannot return a promise`). Since
+   *   every Nextly service method is async, we cannot use Drizzle's native SQLite
+   *   transaction. Instead we open the transaction manually via `BEGIN IMMEDIATE`
+   *   on the shared connection, run the callback against `this.db`, and COMMIT or
+   *   ROLLBACK on success/failure. All Drizzle queries against `this.db` during the
+   *   callback window execute on the same synchronous connection and therefore
+   *   participate in the BEGIN/COMMIT boundary.
+   *
+   * ## Why not the adapter's positional `TransactionContext`
+   *
+   * The adapter's `TransactionContext` (`tx.insert(table: string, data: object)`)
+   * builds raw SQL strings internally. Drizzle's fluent API uses the same
+   * parameterized query builder as the rest of the codebase, gives schema-based
+   * type safety, and is the pattern (db-adapters refactor) standardized on.
+   * The positional adapter context is only kept for legacy collection-service code
+   * paths that have not yet been migrated.
+   *
+   * @param work - Async function executed inside the transaction. Receives a
+   *   Drizzle instance (transaction on PG/MySQL, shared db on SQLite) as `tx`.
+   * @returns Promise resolving to the function's return value.
+   *
+   * @throws {DatabaseError} If the transaction fails or is rolled back.
+   *
+   * @example Basic insert + insert atomic
+   * ```typescript
+   * async createUserWithProfile(userData: NewUser, profileData: NewProfile): Promise<User> {
+   *   return this.withTransaction(async (tx: any) => {
+   *     const [user] = await tx.insert(this.tables.users).values(userData).returning();
+   *     await tx.insert(this.tables.profiles).values({ ...profileData, userId: user.id });
+   *     return user;
+   *   });
+   * }
+   * ```
+   *
+   * @example Update with rollback on validation failure
+   * ```typescript
+   * async transferCredits(fromId: string, toId: string, amount: number): Promise<void> {
+   *   await this.withTransaction(async (tx: any) => {
+   *     await tx.update(this.tables.users)
+   *       .set({ credits: sql`${this.tables.users.credits} - ${amount}` })
+   *       .where(eq(this.tables.users.id, fromId));
+   *
+   *     await tx.update(this.tables.users)
+   *       .set({ credits: sql`${this.tables.users.credits} + ${amount}` })
+   *       .where(eq(this.tables.users.id, toId));
+   *
+   *     const [sender] = await tx.select().from(this.tables.users)
+   *       .where(eq(this.tables.users.id, fromId));
+   *
+   *     if (sender.credits < 0) {
+   *       // Throwing rolls back BOTH updates atomically.
+   *       throw new Error('Insufficient credits');
+   *     }
+   *   });
+   * }
+   * ```
+   */
+  // The tx argument is dialect-typed (NodePgTransaction / MySql2Transaction /
+  // BetterSQLite3Database). Importing all three would bind BaseService to all
+  // three driver packages and break tree-shaking, so we use `unknown` here and
+  // callers narrow with `(tx: any)` if they need fluent chaining. The fluent
+  // query API surface is identical across all three so most callers don't need
+  // a cast beyond that.
+  async withTransaction(work) {
+    if (this.dialect === "sqlite") {
+      await this.db.run(sqliteBeginImmediate);
+      try {
+        const result = await work(this.db);
+        await this.db.run(sqliteCommit);
+        return result;
+      } catch (err) {
+        try {
+          await this.db.run(sqliteRollback);
+        } catch {
+        }
+        throw err;
+      }
+    }
+    return this.db.transaction(work);
+  }
+  /**
+   * Build a simple WHERE clause for equality comparison.
+   *
+   * This is a convenience method for the most common WHERE clause pattern.
+   * For more complex queries, use `whereAnd()` or build the clause manually.
+   *
+   * @param column - Column name to filter
+   * @param value - Value to match (string, number, boolean, Date, null, or undefined)
+   * @returns WHERE clause object
+   *
+   * @example Basic equality
+   * ```typescript
+   * const user = await this.adapter.selectOne<User>('users', {
+   *   where: this.whereEq('email', 'user@example.com'),
+   * });
+   * ```
+   *
+   * @example With null value
+   * ```typescript
+   * const unverifiedUsers = await this.adapter.select<User>('users', {
+   *   where: this.whereEq('emailVerifiedAt', null),
+   * });
+   * ```
+   *
+   * @example In update operation
+   * ```typescript
+   * await this.adapter.update<User>(
+   *   'users',
+   *   { status: 'active' },
+   *   this.whereEq('id', userId),
+   *   { returning: '*' }
+   * );
+   * ```
+   *
+   * @example In delete operation
+   * ```typescript
+   * await this.adapter.delete('sessions', this.whereEq('userId', userId));
+   * ```
+   */
+  whereEq(column, value) {
+    return {
+      and: [{ column, op: "=", value }]
+    };
+  }
+  /**
+   * Build a WHERE clause with multiple AND conditions.
+   *
+   * All conditions must be true for a row to match. This is equivalent to
+   * SQL: `WHERE column1 = value1 AND column2 = value2 AND ...`
+   *
+   * For single equality checks, prefer `whereEq()` for simplicity.
+   * For OR conditions, build the clause manually using the WhereClause structure.
+   *
+   * @param conditions - Object mapping column names to their values
+   * @returns WHERE clause object with AND conditions
+   *
+   * @example Multiple filters
+   * ```typescript
+   * const activeAdmins = await this.adapter.select<User>('users', {
+   *   where: this.whereAnd({
+   *     role: 'admin',
+   *     status: 'active',
+   *     emailVerified: true,
+   *   }),
+   * });
+   * ```
+   *
+   * @example With null values
+   * ```typescript
+   * const pendingUsers = await this.adapter.select<User>('users', {
+   *   where: this.whereAnd({
+   *     status: 'pending',
+   *     emailVerifiedAt: null,
+   *   }),
+   * });
+   * ```
+   *
+   * @example Combined with other options
+   * ```typescript
+   * const results = await this.adapter.select<Document>('documents', {
+   *   where: this.whereAnd({
+   *     collectionSlug: 'posts',
+   *     status: 'published',
+   *   }),
+   *   orderBy: [{ column: 'createdAt', direction: 'desc' }],
+   *   limit: 10,
+   * });
+   * ```
+   *
+   * @example In transaction
+   * ```typescript
+   * await this.withTransaction(async (tx) => {
+   *   const drafts = await tx.select<Document>('documents', {
+   *     where: this.whereAnd({
+   *       userId: currentUserId,
+   *       status: 'draft',
+   *     }),
+   *   });
+   *
+   *   // Process drafts...
+   * });
+   * ```
+   *
+   * @example For complex OR conditions, build manually
+   * ```typescript
+   * // For: WHERE (role = 'admin' AND status = 'active') OR (role = 'superadmin')
+   * const complexWhere: WhereClause = {
+   *   or: [
+   *     this.whereAnd({ role: 'admin', status: 'active' }),
+   *     this.whereEq('role', 'superadmin'),
+   *   ],
+   * };
+   * const users = await this.adapter.select<User>('users', { where: complexWhere });
+   * ```
+   */
+  whereAnd(conditions) {
+    return {
+      and: Object.entries(conditions).map(([column, value]) => ({
+        column,
+        op: "=",
+        value
+      }))
+    };
+  }
+  /**
+   * Check if the current database supports a specific feature.
+   *
+   * Use this method to write database-agnostic code that gracefully handles
+   * database-specific features. The adapter will automatically provide fallbacks
+   * for unsupported features when possible.
+   *
+   * ## Database Capabilities
+   *
+   * | Feature              | PostgreSQL | MySQL | SQLite |
+   * |----------------------|------------|-------|--------|
+   * | supportsJsonb        | ✅         | ❌    | ❌     |
+   * | supportsJson         | ✅         | ✅    | ✅     |
+   * | supportsArrays       | ✅         | ❌    | ❌     |
+   * | supportsIlike        | ✅         | ❌    | ❌     |
+   * | supportsReturning    | ✅         | ❌    | ✅     |
+   * | supportsSavepoints   | ✅         | ❌    | ✅     |
+   * | supportsOnConflict   | ✅         | ✅    | ✅     |
+   * | supportsFts          | ✅         | ⚠️    | ❌     |
+   *
+   * @param feature - Feature name from DatabaseCapabilities
+   * @returns True if the database supports the feature
+   *
+   * @example Case-insensitive search
+   * ```typescript
+   * async searchByEmail(email: string): Promise<User[]> {
+   *   if (this.supportsFeature('supportsIlike')) {
+   *     // PostgreSQL: Use native ILIKE
+   *     return this.adapter.select<User>('users', {
+   *       where: { and: [{ column: 'email', op: 'ILIKE', value: `%${email}%` }] },
+   *     });
+   *   } else {
+   *     // MySQL/SQLite: Adapter handles LOWER() LIKE fallback
+   *     return this.adapter.select<User>('users', {
+   *       where: { and: [{ column: 'email', op: 'ILIKE', value: `%${email}%` }] },
+   *     });
+   *     // Note: Adapter automatically converts ILIKE to LOWER() LIKE for MySQL/SQLite
+   *   }
+   * }
+   * ```
+   *
+   * @example RETURNING clause support
+   * ```typescript
+   * async updateAndReturn(id: string, data: Partial<User>): Promise<User> {
+   *   if (this.supportsFeature('supportsReturning')) {
+   *     // PostgreSQL/SQLite: Use RETURNING
+   *     const [updated] = await this.adapter.update<User>(
+   *       'users',
+   *       data,
+   *       this.whereEq('id', id),
+   *       { returning: '*' }
+   *     );
+   *     return updated;
+   *   } else {
+   *     // MySQL: Adapter automatically does UPDATE + SELECT
+   *     const [updated] = await this.adapter.update<User>(
+   *       'users',
+   *       data,
+   *       this.whereEq('id', id),
+   *       { returning: '*' }
+   *     );
+   *     return updated;
+   *     // Note: Adapter handles the two-query pattern automatically
+   *   }
+   * }
+   * ```
+   *
+   * @example Savepoint usage
+   * ```typescript
+   * async complexUpdate(): Promise<void> {
+   *   await this.withTransaction(async (tx) => {
+   *     await tx.insert('audit_log', { action: 'started' });
+   *
+   *     if (this.supportsFeature('supportsSavepoints') && tx.savepoint) {
+   *       await tx.savepoint('before_update');
+   *
+   *       try {
+   *         await tx.update('sensitive_data', { value: 'new' }, this.whereEq('id', '1'));
+   *       } catch (error) {
+   *         await tx.rollbackToSavepoint!('before_update');
+   *         this.logger.warn('Update failed, rolled back to savepoint');
+   *       }
+   *     } else {
+   *       // MySQL: No savepoints, handle differently
+   *       await tx.update('sensitive_data', { value: 'new' }, this.whereEq('id', '1'));
+   *     }
+   *   });
+   * }
+   * ```
+   *
+   * @example JSON/JSONB storage
+   * ```typescript
+   * async storeMetadata(id: string, metadata: object): Promise<void> {
+   *   if (this.supportsFeature('supportsJsonb')) {
+   *     // PostgreSQL: Use JSONB for better performance
+   *     this.logger.info('Using JSONB column for metadata');
+   *   } else if (this.supportsFeature('supportsJson')) {
+   *     // MySQL/SQLite: Use JSON column
+   *     this.logger.info('Using JSON column for metadata');
+   *   }
+   *
+   *   await this.adapter.update(
+   *     'documents',
+   *     { metadata: JSON.stringify(metadata) },
+   *     this.whereEq('id', id)
+   *   );
+   * }
+   * ```
+   *
+   * @example All capabilities
+   * ```typescript
+   * logDatabaseCapabilities(): void {
+   *   const caps = this.adapter.getCapabilities();
+   *   this.logger.info('Database capabilities', {
+   *     dialect: caps.dialect,
+   *     jsonb: caps.supportsJsonb,
+   *     arrays: caps.supportsArrays,
+   *     ilike: caps.supportsIlike,
+   *     returning: caps.supportsReturning,
+   *     savepoints: caps.supportsSavepoints,
+   *     fts: caps.supportsFts,
+   *   });
+   * }
+   * ```
+   */
+  supportsFeature(feature) {
+    const capabilities = this.adapter.getCapabilities();
+    return !!capabilities[feature];
+  }
+  /**
+   * Format a Date for database insertion.
+   *
+   * MySQL requires datetime in 'YYYY-MM-DD HH:MM:SS' format, while PostgreSQL
+   * and SQLite accept ISO 8601 format ('YYYY-MM-DDTHH:MM:SS.sssZ').
+   *
+   * @param date - Date to format (defaults to current date/time)
+   * @returns Formatted date string appropriate for the current database dialect
+   *
+   * @example
+   * ```typescript
+   * const now = this.formatDateForDb();
+   * await this.adapter.insert('records', { created_at: now });
+   * ```
+   */
+  formatDateForDb(date = /* @__PURE__ */ new Date()) {
+    return date;
+  }
+  /**
+   * Normalize a value from the database into a standard ISO 8601 UTC string.
+   *
+   * Crucial for dynamic tables (Singles) where the DB driver might parse
+   * naive datetime strings using the server's local timezone.
+   *
+   * @param value - The value from the database (Date, string, or unknown)
+   * @returns Optimized ISO string with explicit UTC 'Z' offset
+   */
+  normalizeDbTimestamp(value) {
+    return normalizeDbTimestamp(value);
+  }
+};
+
+export {
+  normalizeDbTimestamp,
+  withTimezoneFormatting,
+  BaseService
+};