ugly-app 0.1.310 → 0.1.311

package/src/server/PostgresDB.ts

@@ -1,263 +0,0 @@
-import type { DBObject, DocFields, FindOptions, MongoUpdateOp, TypedFilter } from '../shared/DB.js';
-import { query } from './Postgres.js';
-import { translateFilter, translateSort } from './PostgresFilter.js';
-import { applyUpdateOp } from './PostgresOperators.js';
-import { translatePipeline } from './PostgresPipeline.js';
-
-/** Merge JSONB data with top-level DB columns into a document */
-function toDoc<T extends DBObject>(row: {
-  _id: string;
-  data: Record<string, unknown>;
-  created: Date;
-  updated: Date;
-  version: number;
-}): T {
-  return {
-    ...row.data,
-    _id: row._id,
-    created: row.created,
-    updated: row.updated,
-    version: row.version,
-  } as unknown as T;
-}
-
-/** Strip DB metadata fields from a doc to get the JSONB data payload */
-function toData(doc: DBObject): Record<string, unknown> {
-  const { _id: _, version: _v, created: _c, updated: _u, ...data } = doc as unknown as Record<string, unknown>;
-  return data;
-}
-
-interface FullRow { _id: string; data: Record<string, unknown>; created: Date; updated: Date; version: number }
-
-export async function pgGetDoc<T extends DBObject>(
-  collection: string,
-  id: string,
-): Promise<T | null> {
-  const result = await query<FullRow>(
-    `SELECT _id, data, created, updated, version FROM "${collection}" WHERE _id = $1`,
-    [id],
-  );
-  if (result.rows.length === 0) return null;
-  return toDoc<T>(result.rows[0]);
-}
-
-export async function pgSetDoc<T extends DBObject>(
-  collection: string,
-  doc: T,
-  options?: { skipIfExists?: boolean },
-): Promise<boolean> {
-  const data = toData(doc);
-
-  if (options?.skipIfExists) {
-    const result = await query(
-      `INSERT INTO "${collection}" (_id, data, created, updated, version)
-       VALUES ($1, $2, $3, $4, $5)
-       ON CONFLICT (_id) DO NOTHING`,
-      [doc._id, JSON.stringify(data), doc.created, doc.updated, doc.version],
-    );
-    return (result.rowCount ?? 0) > 0;
-  }
-
-  await query(
-    `INSERT INTO "${collection}" (_id, data, created, updated, version)
-     VALUES ($1, $2, $3, $4, $5)
-     ON CONFLICT (_id) DO UPDATE SET
-       data = EXCLUDED.data,
-       updated = EXCLUDED.updated,
-       version = EXCLUDED.version`,
-    [doc._id, JSON.stringify(data), doc.created, doc.updated, doc.version],
-  );
-  return true;
-}
-
-export async function pgSetDocFields<T extends DBObject>(
-  collection: string,
-  id: string,
-  fields: DocFields<T>,
-): Promise<T> {
-  const result = await applyUpdateOp(collection, id, { $set: fields as Record<string, unknown> });
-  if (!result) throw new Error(`[DB] Document not found: ${collection}/${id}`);
-  return result as unknown as T;
-}
-
-export async function pgSetDocFieldsOrIgnore<T extends DBObject>(
-  collection: string,
-  id: string,
-  fields: DocFields<T>,
-): Promise<T | null> {
-  const result = await applyUpdateOp(collection, id, { $set: fields as Record<string, unknown> });
-  return result as unknown as T | null;
-}
-
-export async function pgSetDocFieldsOrCreate<T extends DBObject>(
-  collection: string,
-  id: string,
-  fields: DocFields<T>,
-  obj: T,
-): Promise<T> {
-  const existing = await pgSetDocFieldsOrIgnore<T>(collection, id, fields);
-  if (existing) return existing;
-  await pgSetDoc(collection, obj);
-  return obj;
-}
-
-export async function pgSetDocOp<T extends DBObject>(
-  collection: string,
-  id: string,
-  op: MongoUpdateOp<T>,
-): Promise<T> {
-  const result = await applyUpdateOp(collection, id, op as Record<string, unknown>);
-  if (!result) throw new Error(`[DB] Document not found: ${collection}/${id}`);
-  return result as unknown as T;
-}
-
-export async function pgSetDocOpOrIgnore<T extends DBObject>(
-  collection: string,
-  id: string,
-  op: MongoUpdateOp<T>,
-): Promise<T | null> {
-  const result = await applyUpdateOp(collection, id, op as Record<string, unknown>);
-  return result as unknown as T | null;
-}
-
-export async function pgDeleteDoc(
-  collection: string,
-  id: string,
-): Promise<void> {
-  await query(`DELETE FROM "${collection}" WHERE _id = $1`, [id]);
-}
-
-export async function pgGetDocs<T extends DBObject>(
-  collection: string,
-  filter: Record<string, unknown> = {},
-  options: {
-    sort?: Record<string, 1 | -1>;
-    limit?: number;
-    skip?: number;
-  } = {},
-): Promise<T[]> {
-  const { where, values } = translateFilter(filter);
-  let sql = `SELECT _id, data, created, updated, version FROM "${collection}"`;
-  if (where) sql += ` WHERE ${where}`;
-  if (options.sort) sql += ` ORDER BY ${translateSort(options.sort)}`;
-  if (options.limit) {
-    values.push(options.limit);
-    sql += ` LIMIT $${values.length}`;
-  }
-  if (options.skip) {
-    values.push(options.skip);
-    sql += ` OFFSET $${values.length}`;
-  }
-
-  const result = await query<FullRow>(sql, values);
-  return result.rows.map((row) => toDoc<T>(row));
-}
-
-export async function pgGetQuery<T>(
-  collection: string,
-  pipeline: Record<string, unknown>[],
-  options?: { skip?: number; limit?: number },
-): Promise<T[]> {
-  const { sql, values } = translatePipeline(collection, pipeline, options);
-  const result = await query(sql, values);
-  return result.rows.map((row) => {
-    if (row.data && row._id !== undefined && row.created !== undefined) {
-      return toDoc(row as FullRow) as unknown as T;
-    }
-    return row as unknown as T;
-  });
-}
-
-export async function pgGetQueryCount(
-  collection: string,
-  pipeline: Record<string, unknown>[],
-): Promise<number> {
-  const { sql, values } = translatePipeline(collection, [...pipeline, { $count: 'count' }]);
-  const result = await query<{ count: string }>(sql, values);
-  return Number(result.rows[0]?.count ?? 0);
-}
-
-export async function pgGetQueryRaw<T>(
-  collection: string,
-  pipeline: Record<string, unknown>[],
-  options?: { skip?: number; limit?: number },
-): Promise<T[]> {
-  const { sql, values } = translatePipeline(collection, pipeline, options);
-  const result = await query(sql, values);
-  return result.rows as unknown as T[];
-}
-
-export async function pgDeleteDocs(
-  collection: string,
-  filter: Record<string, unknown>,
-): Promise<string[]> {
-  const { where, values } = translateFilter(filter);
-  let sql = `DELETE FROM "${collection}"`;
-  if (where) sql += ` WHERE ${where}`;
-  sql += ` RETURNING _id`;
-
-  const result = await query<{ _id: string }>(sql, values);
-  return result.rows.map((r) => r._id);
-}
-
-// ---------------------------------------------------------------------------
-// Typed SQL-native query functions
-// ---------------------------------------------------------------------------
-
-export async function pgFind<T extends DBObject>(
-  collection: string,
-  filter: TypedFilter<T> = {} as TypedFilter<T>,
-  options: FindOptions<T> = {} as FindOptions<T>,
-): Promise<T[]> {
-  const { where, values } = translateFilter(filter as Record<string, unknown>);
-  let sql = `SELECT _id, data, created, updated, version FROM "${collection}"`;
-  if (where) sql += ` WHERE ${where}`;
-  if (options.sort) sql += ` ORDER BY ${translateSort(options.sort as Record<string, 1 | -1>)}`;
-  if (options.limit) {
-    values.push(options.limit);
-    sql += ` LIMIT $${values.length}`;
-  }
-  if (options.skip) {
-    values.push(options.skip);
-    sql += ` OFFSET $${values.length}`;
-  }
-  const result = await query<FullRow>(sql, values);
-  return result.rows.map((row) => toDoc<T>(row));
-}
-
-export async function pgFindCount<T>(
-  collection: string,
-  filter: TypedFilter<T> = {} as TypedFilter<T>,
-): Promise<number> {
-  const { where, values } = translateFilter(filter as Record<string, unknown>);
-  let sql = `SELECT COUNT(*)::int AS count FROM "${collection}"`;
-  if (where) sql += ` WHERE ${where}`;
-  const result = await query<{ count: number }>(sql, values);
-  return result.rows[0]?.count ?? 0;
-}
-
-export async function pgFindRandom<T extends DBObject>(
-  collection: string,
-  filter: TypedFilter<T> = {} as TypedFilter<T>,
-  limit = 100,
-): Promise<T[]> {
-  const { where, values } = translateFilter(filter as Record<string, unknown>);
-  let sql = `SELECT _id, data, created, updated, version FROM "${collection}"`;
-  if (where) sql += ` WHERE ${where}`;
-  values.push(limit);
-  sql += ` ORDER BY RANDOM() LIMIT $${values.length}`;
-  const result = await query<FullRow>(sql, values);
-  return result.rows.map((row) => toDoc<T>(row));
-}
-
-export async function pgDeleteWhere<T>(
-  collection: string,
-  filter: TypedFilter<T>,
-): Promise<string[]> {
-  const { where, values } = translateFilter(filter as Record<string, unknown>);
-  let sql = `DELETE FROM "${collection}"`;
-  if (where) sql += ` WHERE ${where}`;
-  sql += ` RETURNING _id`;
-  const result = await query<{ _id: string }>(sql, values);
-  return result.rows.map((r) => r._id);
-}

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,
-  };
-}