ugly-app 0.1.310 → 0.1.312

package/src/server/PostgresFilter.ts

@@ -1,162 +0,0 @@
-/**
- * Translates MongoDB-style filter objects into PostgreSQL JSONB WHERE clauses.
- *
- * Supports: equality, $in, $nin, $gt, $gte, $lt, $lte, $ne, $exists.
- * Fields are accessed via JSONB operators (data->>'field' for text, casts for numbers/booleans).
- * Dot-notation paths (e.g. 'user.profile.name') are translated to -> chains.
- */
-
-export interface TranslatedFilter {
-  where: string;
-  values: unknown[];
-}
-
-/** Fields stored as top-level columns rather than inside the JSONB data column. */
-const TOP_LEVEL_COLUMNS = new Set(['_id', 'created', 'updated', 'version']);
-
-/** Top-level columns that store timestamps (TIMESTAMPTZ). Numeric values must be converted to Date. */
-const TIMESTAMP_COLUMNS = new Set(['created', 'updated']);
-
-/** Convert a value to a Date if it's a numeric epoch for a timestamp column. */
-function coerceTimestamp(field: string, value: unknown): unknown {
-  if (TIMESTAMP_COLUMNS.has(field) && typeof value === 'number') {
-    return new Date(value);
-  }
-  return value;
-}
-
-/** Build the JSONB accessor for a field path. Last segment uses ->> (text extraction). */
-function jsonbPath(field: string, asText = true): string {
-  if (TOP_LEVEL_COLUMNS.has(field)) return `"${field}"`;
-  const parts = field.split('.');
-  if (parts.length === 1) {
-    return asText ? `data->>'${parts[0]}'` : `data->'${parts[0]}'`;
-  }
-  const chain = parts.slice(0, -1).map((p) => `'${p}'`).join('->');
-  const last = parts[parts.length - 1];
-  return asText ? `data->${chain}->>'${last}'` : `data->${chain}->'${last}'`;
-}
-
-function isOperatorObject(value: unknown): value is Record<string, unknown> {
-  if (typeof value !== 'object' || value === null || Array.isArray(value)) return false;
-  return Object.keys(value).some((k) => k.startsWith('$'));
-}
-
-export function translateFilter(filter: Record<string, unknown>): TranslatedFilter {
-  const clauses: string[] = [];
-  const values: unknown[] = [];
-  let paramIdx = 1;
-
-  for (const [field, value] of Object.entries(filter)) {
-    if (isOperatorObject(value)) {
-      for (const [op, operand] of Object.entries(value)) {
-        switch (op) {
-          case '$in':
-            // MongoDB: {field: {$in: [vals]}} matches if field is scalar and equals any val,
-            // OR if field is an array and contains any val.
-            // Top-level columns (_id, etc.) are plain TEXT — skip the JSONB overlap check.
-            if (TOP_LEVEL_COLUMNS.has(field)) {
-              clauses.push(`${jsonbPath(field)} = ANY($${paramIdx})`);
-            } else {
-              clauses.push(`(${jsonbPath(field)} = ANY($${paramIdx}) OR ${jsonbPath(field, false)} ?| $${paramIdx})`);
-            }
-            values.push(operand);
-            paramIdx++;
-            break;
-          case '$nin':
-            // Inverse: scalar not in ANY, AND array doesn't overlap
-            if (TOP_LEVEL_COLUMNS.has(field)) {
-              clauses.push(`${jsonbPath(field)} != ALL($${paramIdx})`);
-            } else {
-              clauses.push(`(${jsonbPath(field)} != ALL($${paramIdx}) AND NOT (${jsonbPath(field, false)} ?| $${paramIdx}))`);
-            }
-            values.push(operand);
-            paramIdx++;
-            break;
-          case '$gt': {
-            const acc = jsonbPath(field);
-            const cast = TOP_LEVEL_COLUMNS.has(field) ? acc : `(${acc})::numeric`;
-            clauses.push(`${cast} > $${paramIdx}`);
-            values.push(coerceTimestamp(field, operand));
-            paramIdx++;
-            break;
-          }
-          case '$gte': {
-            const acc = jsonbPath(field);
-            const cast = TOP_LEVEL_COLUMNS.has(field) ? acc : `(${acc})::numeric`;
-            clauses.push(`${cast} >= $${paramIdx}`);
-            values.push(coerceTimestamp(field, operand));
-            paramIdx++;
-            break;
-          }
-          case '$lt': {
-            const acc = jsonbPath(field);
-            const cast = TOP_LEVEL_COLUMNS.has(field) ? acc : `(${acc})::numeric`;
-            clauses.push(`${cast} < $${paramIdx}`);
-            values.push(coerceTimestamp(field, operand));
-            paramIdx++;
-            break;
-          }
-          case '$lte': {
-            const acc = jsonbPath(field);
-            const cast = TOP_LEVEL_COLUMNS.has(field) ? acc : `(${acc})::numeric`;
-            clauses.push(`${cast} <= $${paramIdx}`);
-            values.push(coerceTimestamp(field, operand));
-            paramIdx++;
-            break;
-          }
-          case '$ne':
-            clauses.push(`${jsonbPath(field)} != $${paramIdx}`);
-            values.push(coerceTimestamp(field, operand));
-            paramIdx++;
-            break;
-          case '$exists':
-            if (operand) {
-              clauses.push(`data ? '${field}'`);
-            } else {
-              clauses.push(`NOT (data ? '${field}')`);
-            }
-            break;
-          default:
-            throw new Error(`[DB] Unsupported filter operator: ${op}`);
-        }
-      }
-    } else if (value === null) {
-      clauses.push(`${jsonbPath(field, false)} IS NULL OR ${jsonbPath(field)} = 'null'`);
-    } else if (typeof value === 'number') {
-      if (TIMESTAMP_COLUMNS.has(field)) {
-        clauses.push(`${jsonbPath(field)} = $${paramIdx}`);
-        values.push(new Date(value));
-      } else {
-        clauses.push(`(${jsonbPath(field)})::numeric = $${paramIdx}`);
-        values.push(value);
-      }
-      paramIdx++;
-    } else if (typeof value === 'boolean') {
-      clauses.push(`(${jsonbPath(field)})::boolean = $${paramIdx}`);
-      values.push(value);
-      paramIdx++;
-    } else {
-      // String or other — use text equality
-      const accessor = field === '_id' ? '_id' : jsonbPath(field);
-      clauses.push(`${accessor} = $${paramIdx}`);
-      values.push(value);
-      paramIdx++;
-    }
-  }
-
-  return {
-    where: clauses.join(' AND '),
-    values,
-  };
-}
-
-/** Translate MongoDB sort to ORDER BY clause. */
-export function translateSort(sort: Record<string, 1 | -1>): string {
-  return Object.entries(sort)
-    .map(([field, dir]) => {
-      const accessor = TOP_LEVEL_COLUMNS.has(field) ? `"${field}"` : jsonbPath(field);
-      return `${accessor} ${dir === 1 ? 'ASC' : 'DESC'}`;
-    })
-    .join(', ');
-}

package/src/server/PostgresOperators.ts

@@ -1,136 +0,0 @@
-import { query } from './Postgres.js';
-
-/**
- * Translates MongoDB update operators ($set, $unset, $inc, $addToSet, $pull)
- * into a single PostgreSQL UPDATE statement using JSONB functions.
- *
- * Returns the updated document's data, or null if the document doesn't exist.
- */
-
-interface UpdateOp {
-  $set?: Record<string, unknown>;
-  $unset?: Record<string, string>;
-  $inc?: Record<string, number>;
-  $addToSet?: Record<string, unknown>;
-  $pull?: Record<string, unknown>;
-}
-
-/** Convert a dot-notation path to a PostgreSQL path array: 'a.b.c' → '{a,b,c}' */
-function toPathArray(field: string): string {
-  return `{${field.split('.').join(',')}}`;
-}
-
-/**
- * Build a SQL expression that applies all operators to the data column.
- * Each operator wraps the previous expression, building up the transformation.
- */
-function buildUpdateExpression(op: UpdateOp): { expr: string; values: unknown[]; paramStart: number } {
-  let expr = 'data';
-  const values: unknown[] = [];
-  let paramIdx = 2; // $1 is always the _id
-
-  // $set: jsonb_set for each field
-  // For nested paths (e.g. 'buttons.botId'), ensure intermediate objects exist.
-  // PostgreSQL's jsonb_set only creates the leaf key, not intermediate parents.
-  // If the parent is null or missing, jsonb_set returns NULL which violates NOT NULL.
-  if (op.$set) {
-    for (const [field, value] of Object.entries(op.$set)) {
-      const parts = field.split('.');
-      if (parts.length > 1) {
-        // Ensure each intermediate path exists as an object
-        for (let i = 1; i < parts.length; i++) {
-          const parentPath = toPathArray(parts.slice(0, i).join('.'));
-          expr = `jsonb_set(${expr}, '${parentPath}', COALESCE(${expr}#>'${parentPath}', '{}'::jsonb))`;
-        }
-      }
-      expr = `jsonb_set(${expr}, '${toPathArray(field)}', $${paramIdx}::jsonb)`;
-      values.push(JSON.stringify(value));
-      paramIdx++;
-    }
-  }
-
-  // $unset: remove keys
-  if (op.$unset) {
-    for (const field of Object.keys(op.$unset)) {
-      const parts = field.split('.');
-      if (parts.length === 1) {
-        expr = `(${expr}) - '${field}'`;
-      } else {
-        // For nested: remove the last key from the parent path.
-        // COALESCE guards against NULL when the parent path doesn't exist,
-        // which would cause jsonb_set to return NULL and violate NOT NULL.
-        const parentPath = toPathArray(parts.slice(0, -1).join('.'));
-        const lastKey = parts[parts.length - 1];
-        expr = `jsonb_set(${expr}, '${parentPath}', COALESCE((${expr}#>'${parentPath}') - '${lastKey}', '{}'::jsonb))`;
-      }
-    }
-  }
-
-  // $inc: increment numeric values
-  if (op.$inc) {
-    for (const [field, amount] of Object.entries(op.$inc)) {
-      const path = toPathArray(field);
-      expr = `jsonb_set(${expr}, '${path}', to_jsonb(COALESCE((${expr}#>>'{${field.split('.').join(',')}}')::numeric, 0) + $${paramIdx}))`;
-      values.push(amount);
-      paramIdx++;
-    }
-  }
-
-  // $addToSet: add to array if not present
-  if (op.$addToSet) {
-    for (const [field, value] of Object.entries(op.$addToSet)) {
-      const path = toPathArray(field);
-      const jsonVal = `$${paramIdx}::jsonb`;
-      expr = `jsonb_set(${expr}, '${path}', CASE WHEN (${expr}#>'${path}') @> ${jsonVal} THEN (${expr}#>'${path}') ELSE (${expr}#>'${path}') || ${jsonVal} END)`;
-      values.push(JSON.stringify(value));
-      paramIdx++;
-    }
-  }
-
-  // $pull: remove element from array
-  if (op.$pull) {
-    for (const [field, value] of Object.entries(op.$pull)) {
-      const path = toPathArray(field);
-      const jsonVal = `$${paramIdx}::jsonb`;
-      expr = `jsonb_set(${expr}, '${path}', (SELECT COALESCE(jsonb_agg(elem), '[]'::jsonb) FROM jsonb_array_elements(${expr}#>'${path}') elem WHERE elem != ${jsonVal}))`;
-      values.push(JSON.stringify(value));
-      paramIdx++;
-    }
-  }
-
-  return { expr, values, paramStart: paramIdx };
-}
-
-export async function applyUpdateOp(
-  collection: string,
-  id: string,
-  op: UpdateOp,
-): Promise<Record<string, unknown> | null> {
-  const { expr, values } = buildUpdateExpression(op);
-
-  const sql = `
-    UPDATE "${collection}"
-    SET data = ${expr}, updated = now(), version = version + 1
-    WHERE _id = $1
-    RETURNING data, _id, created, updated, version
-  `;
-
-  const result = await query<{
-    data: Record<string, unknown>;
-    _id: string;
-    created: Date;
-    updated: Date;
-    version: number;
-  }>(sql, [id, ...values]);
-
-  if (result.rows.length === 0) return null;
-
-  const row = result.rows[0];
-  return {
-    ...row.data,
-    _id: row._id,
-    created: row.created,
-    updated: row.updated,
-    version: row.version,
-  };
-}

package/src/server/PostgresPipeline.ts

@@ -1,262 +0,0 @@
-/**
- * Translates a subset of MongoDB aggregation pipeline stages into PostgreSQL SQL.
- *
- * Supported stages: $match, $sort, $limit, $skip, $count, $group
- * Supported $group accumulators: $sum, $avg, $min, $max, $first, $last
- */
-
-import { translateFilter } from './PostgresFilter.js';
-
-interface QueryParts {
-  select: string;
-  from: string;
-  where: string[];
-  groupBy: string[];
-  orderBy: string[];
-  limit: number | null;
-  offset: number | null;
-  values: unknown[];
-  paramIdx: number;
-  /** True after a $group stage has been applied */
-  grouped: boolean;
-}
-
-export interface TranslatedPipeline {
-  sql: string;
-  values: unknown[];
-}
-
-/** Build JSONB accessor for a field in the base table */
-function jsonbPath(field: string, asText = true): string {
-  if (field === '_id') return '"_id"';
-  const parts = field.split('.');
-  if (parts.length === 1) {
-    return asText ? `data->>'${parts[0]}'` : `data->'${parts[0]}'`;
-  }
-  const chain = parts.slice(0, -1).map((p) => `'${p}'`).join('->');
-  const last = parts[parts.length - 1];
-  return asText ? `data->${chain}->>'${last}'` : `data->${chain}->'${last}'`;
-}
-
-/** Wrap current query parts into a subquery, resetting for further stages */
-function wrapAsSubquery(parts: QueryParts): QueryParts {
-  const innerSql = buildSql(parts);
-  return {
-    select: '*',
-    from: `(${innerSql}) AS _sub${parts.paramIdx}`,
-    where: [],
-    groupBy: [],
-    orderBy: [],
-    limit: null,
-    offset: null,
-    values: [...parts.values],
-    paramIdx: parts.paramIdx,
-    grouped: false,
-  };
-}
-
-function buildSql(parts: QueryParts): string {
-  let sql = `SELECT ${parts.select} FROM ${parts.from}`;
-  if (parts.where.length > 0) {
-    sql += ` WHERE ${parts.where.join(' AND ')}`;
-  }
-  if (parts.groupBy.length > 0) {
-    sql += ` GROUP BY ${parts.groupBy.join(', ')}`;
-  }
-  if (parts.orderBy.length > 0) {
-    sql += ` ORDER BY ${parts.orderBy.join(', ')}`;
-  }
-  if (parts.limit !== null) {
-    sql += ` LIMIT ${parts.limit}`;
-  }
-  if (parts.offset !== null) {
-    sql += ` OFFSET ${parts.offset}`;
-  }
-  return sql;
-}
-
-function applyMatch(parts: QueryParts, match: Record<string, unknown>): void {
-  if (parts.grouped) {
-    // After a $group, wrap as subquery and match against aliased columns
-    const wrapped = wrapAsSubquery(parts);
-    Object.assign(parts, wrapped);
-  }
-
-  const { where, values } = translateFilter(match);
-  if (!where) return;
-
-  // Rewrite param placeholders from $1-based to current paramIdx
-  let rewritten = where;
-  // Replace from highest to lowest to avoid $1 matching $10, $11, etc.
-  for (let i = values.length; i >= 1; i--) {
-    const newIdx = parts.paramIdx + i - 1;
-    rewritten = rewritten.replace(new RegExp(`\\$${i}(?!\\d)`, 'g'), `$${newIdx}`);
-  }
-
-  parts.where.push(rewritten);
-  parts.values.push(...values);
-  parts.paramIdx += values.length;
-}
-
-function applySort(parts: QueryParts, sort: Record<string, number>): void {
-  if (parts.grouped) {
-    // After $group, sort uses aliased column names directly
-    const wrapped = wrapAsSubquery(parts);
-    Object.assign(parts, wrapped);
-  }
-
-  parts.orderBy = [];
-  for (const [field, dir] of Object.entries(sort)) {
-    if (parts.from.includes('_sub')) {
-      // Sorting on a subquery — use column names directly
-      parts.orderBy.push(`"${field}" ${dir === 1 ? 'ASC' : 'DESC'}`);
-    } else {
-      const accessor = field === '_id' ? '"_id"' : jsonbPath(field);
-      parts.orderBy.push(`${accessor} ${dir === 1 ? 'ASC' : 'DESC'}`);
-    }
-  }
-}
-
-function applyLimit(parts: QueryParts, limit: number): void {
-  parts.limit = limit;
-}
-
-function applySkip(parts: QueryParts, skip: number): void {
-  parts.offset = skip;
-}
-
-function applyCount(parts: QueryParts, alias: string): void {
-  const innerSql = buildSql(parts);
-  parts.select = `COUNT(*) AS "${alias}"`;
-  parts.from = `(${innerSql}) AS _counted`;
-  parts.where = [];
-  parts.groupBy = [];
-  parts.orderBy = [];
-  parts.limit = null;
-  parts.offset = null;
-  parts.grouped = false;
-}
-
-function resolveAccumulator(acc: Record<string, unknown>): string {
-  const [[op, field]] = Object.entries(acc);
-  const col = typeof field === 'string' && field.startsWith('$')
-    ? jsonbPath(field.slice(1))
-    : String(field);
-
-  switch (op) {
-    case '$sum':
-      if (typeof field === 'number') return String(field);
-      return `SUM((${col})::double precision)`;
-    case '$avg':
-      return `AVG((${col})::double precision)`;
-    case '$min':
-      return `MIN((${col})::double precision)`;
-    case '$max':
-      return `MAX((${col})::double precision)`;
-    case '$first':
-      return `(array_agg(${col}))[1]`;
-    case '$last':
-      return `(array_agg(${col}))[array_length(array_agg(${col}), 1)]`;
-    default:
-      throw new Error(`[DB] Unsupported accumulator: ${op}`);
-  }
-}
-
-function applyGroup(parts: QueryParts, group: Record<string, unknown>): void {
-  const groupId = group._id;
-  const selectParts: string[] = [];
-  const groupByParts: string[] = [];
-
-  // _id field — the group key
-  if (groupId === null) {
-    selectParts.push(`NULL AS "_id"`);
-  } else if (typeof groupId === 'string' && groupId.startsWith('$')) {
-    const field = groupId.slice(1);
-    const accessor = field === '_id' ? '"_id"' : jsonbPath(field);
-    selectParts.push(`${accessor} AS "_id"`);
-    groupByParts.push(accessor);
-  } else {
-    throw new Error(`[DB] Unsupported $group _id expression: ${JSON.stringify(groupId)}`);
-  }
-
-  // Accumulators
-  for (const [alias, expr] of Object.entries(group)) {
-    if (alias === '_id') continue;
-    const resolved = resolveAccumulator(expr as Record<string, unknown>);
-    selectParts.push(`${resolved} AS "${alias}"`);
-  }
-
-  parts.select = selectParts.join(', ');
-  parts.groupBy = groupByParts;
-  parts.grouped = true;
-}
-
-export function translatePipeline(
-  collection: string,
-  pipeline: Record<string, unknown>[],
-  options?: { skip?: number; limit?: number },
-): TranslatedPipeline {
-  const parts: QueryParts = {
-    select: '_id, data, created, updated, version',
-    from: `"${collection}"`,
-    where: [],
-    groupBy: [],
-    orderBy: [],
-    limit: null,
-    offset: null,
-    values: [],
-    paramIdx: 1,
-    grouped: false,
-  };
-
-  for (const stage of pipeline) {
-    const [[key, value]] = Object.entries(stage);
-    switch (key) {
-      case '$match':
-        applyMatch(parts, value as Record<string, unknown>);
-        break;
-      case '$sort':
-        applySort(parts, value as Record<string, number>);
-        break;
-      case '$limit':
-        applyLimit(parts, value as number);
-        break;
-      case '$skip':
-        applySkip(parts, value as number);
-        break;
-      case '$count':
-        applyCount(parts, value as string);
-        break;
-      case '$group':
-        applyGroup(parts, value as Record<string, unknown>);
-        break;
-      // Stages that are sanitized by StoreHandlers but not translatable to SQL;
-      // treat as no-ops so queries resolve without error.
-      case '$addFields':
-      case '$set':
-      case '$project':
-      case '$unwind':
-      case '$sample':
-      case '$replaceRoot':
-      case '$replaceWith':
-      case '$bucket':
-      case '$bucketAuto':
-        break;
-      default:
-        throw new Error(`[DB] Unsupported pipeline stage: ${key}`);
-    }
-  }
-
-  // Apply options (limit/skip) after pipeline stages
-  if (options?.skip !== undefined) {
-    parts.offset = options.skip;
-  }
-  if (options?.limit !== undefined) {
-    parts.limit = options.limit;
-  }
-
-  return {
-    sql: buildSql(parts),
-    values: parts.values,
-  };
-}

package/src/server/PostgresSchema.ts

@@ -1,51 +0,0 @@
-import { query } from './Postgres.js';
-
-export async function ensureTable(collection: string): Promise<void> {
-  // Validate collection name (alphanumeric + underscore only)
-  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(collection)) {
-    throw new Error(`[DB] Invalid collection name: ${collection}`);
-  }
-
-  await query(`
-    CREATE TABLE IF NOT EXISTS "${collection}" (
-      _id      TEXT PRIMARY KEY,
-      data     JSONB NOT NULL,
-      created  TIMESTAMPTZ NOT NULL DEFAULT now(),
-      updated  TIMESTAMPTZ NOT NULL DEFAULT now(),
-      version  INTEGER NOT NULL DEFAULT 1
-    )
-  `);
-
-  // GIN index for JSONB queries
-  await query(`
-    CREATE INDEX IF NOT EXISTS "idx_${collection}_data"
-    ON "${collection}" USING GIN (data)
-  `);
-}
-
-export async function ensureSearchColumn(
-  collection: string,
-  fields: string[],
-  _language = 'english',
-): Promise<void> {
-  await query(`
-    ALTER TABLE "${collection}"
-    ADD COLUMN IF NOT EXISTS search TSVECTOR
-  `);
-
-  await query(`
-    CREATE INDEX IF NOT EXISTS "idx_${collection}_search"
-    ON "${collection}" USING GIN (search)
-  `);
-}
-
-export async function tableExists(collection: string): Promise<boolean> {
-  const result = await query<{ exists: boolean }>(
-    `SELECT EXISTS (
-      SELECT FROM information_schema.tables
-      WHERE table_name = $1
-    ) as exists`,
-    [collection],
-  );
-  return result.rows[0].exists;
-}