ugly-app 0.1.310 → 0.1.311

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

package/src/server/PostgresSearch.ts

@@ -1,109 +0,0 @@
-import type { DBObject } from '../shared/DB.js';
-import { query } from './Postgres.js';
-import { translateFilter } from './PostgresFilter.js';
-
-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)
-  `);
-}
-
-interface FullRow { _id: string; data: Record<string, unknown>; created: Date; updated: Date; version: number }
-
-function toDoc<T extends DBObject>(row: FullRow): T {
-  return {
-    ...row.data,
-    _id: row._id,
-    created: row.created,
-    updated: row.updated,
-    version: row.version,
-  } as unknown as T;
-}
-
-export async function updateSearchColumn(
-  collection: string,
-  id: string,
-  fields: string[],
-  language = 'english',
-): Promise<void> {
-  const fieldExprs = fields.map((f) => `COALESCE(data->>'${f}', '')`);
-  const concat = fieldExprs.join(` || ' ' || `);
-
-  await query(
-    `UPDATE "${collection}"
-     SET search = to_tsvector($1::regconfig, ${concat})
-     WHERE _id = $2`,
-    [language, id],
-  );
-}
-
-export async function pgSearchDocs<T extends DBObject>(
-  collection: string,
-  searchQuery: string,
-  options?: { limit?: number; filter?: Record<string, unknown> },
-): Promise<T[]> {
-  // Build an OR-based tsquery so that documents matching any term are returned,
-  // while ts_rank still rewards documents that match more terms.
-  const terms = searchQuery
-    .trim()
-    .split(/\s+/)
-    .filter(Boolean)
-    .map((t) => t.replace(/[^a-zA-Z0-9]/g, ''))
-    .filter(Boolean);
-
-  const tsqueryExpr =
-    terms.length > 0
-      ? terms.map((_, i) => `plainto_tsquery('english', $${i + 1})`).join(' || ')
-      : `plainto_tsquery('english', $1)`;
-
-  const tsrankExpr =
-    terms.length > 0
-      ? terms.map((_, i) => `plainto_tsquery('english', $${i + 1})`).join(' || ')
-      : `plainto_tsquery('english', $1)`;
-
-  const values: unknown[] = terms.length > 0 ? [...terms] : [searchQuery];
-  let paramIdx = values.length + 1;
-
-  let sql = `
-    SELECT _id, data, created, updated, version,
-           ts_rank(search, ${tsrankExpr}) AS rank
-    FROM "${collection}"
-    WHERE search @@ (${tsqueryExpr})
-  `;
-
-  if (options?.filter) {
-    const { where, values: filterValues } = translateFilter(options.filter);
-    if (where) {
-      let rewritten = where;
-      for (let i = filterValues.length; i >= 1; i--) {
-        rewritten = rewritten.replace(
-          new RegExp(`\\$${i}(?!\\d)`, 'g'),
-          `$${paramIdx + i - 1}`,
-        );
-      }
-      sql += ` AND ${rewritten}`;
-      values.push(...filterValues);
-      paramIdx += filterValues.length;
-    }
-  }
-
-  sql += ` ORDER BY rank DESC`;
-
-  if (options?.limit) {
-    sql += ` LIMIT $${paramIdx}`;
-    values.push(options.limit);
-  }
-
-  const result = await query<FullRow>(sql, values);
-  return result.rows.map((row) => toDoc<T>(row));
-}

package/src/server/Qdrant.ts

@@ -1,110 +0,0 @@
-import { createHash } from 'crypto';
-import { QdrantClient } from '@qdrant/js-client-rest';
-
-let _client: QdrantClient | null = null;
-
-let _collectionPrefix = '';
-
-export function setQdrantPrefix(prefix: string): void {
-  _collectionPrefix = prefix ? `${prefix}_` : '';
-}
-
-function prefixed(name: string): string {
-  return `${_collectionPrefix}${name}`;
-}
-
-/** Convert an arbitrary string ID to a deterministic UUID (v5-like SHA-1 based). */
-function toUUID(id: string): string {
-  const hash = createHash('sha1').update(id).digest('hex');
-  return [
-    hash.slice(0, 8),
-    hash.slice(8, 12),
-    '5' + hash.slice(13, 16),
-    ((parseInt(hash.slice(16, 18), 16) & 0x3f) | 0x80).toString(16).padStart(2, '0') + hash.slice(18, 20),
-    hash.slice(20, 32),
-  ].join('-');
-}
-
-export function initQdrant(url: string): void {
-  _client = new QdrantClient({ url });
-}
-
-export function getQdrantClient(): QdrantClient {
-  if (!_client) throw new Error('[Qdrant] Not initialized — call initQdrant first');
-  return _client;
-}
-
-export function stopQdrant(): void {
-  _client = null;
-}
-
-export async function ensureQdrantCollection(
-  name: string,
-  dimensions: number,
-): Promise<void> {
-  const client = getQdrantClient();
-  const collections = await client.getCollections();
-  const exists = collections.collections.some((c) => c.name === prefixed(name));
-  if (exists) return;
-
-  await client.createCollection(prefixed(name), {
-    vectors: {
-      size: dimensions,
-      distance: 'Cosine',
-      on_disk: true,
-    },
-  });
-}
-
-export async function deleteQdrantCollection(name: string): Promise<void> {
-  const client = getQdrantClient();
-  try {
-    await client.deleteCollection(prefixed(name));
-  } catch {
-    // Collection may not exist
-  }
-}
-
-export async function upsertVector(
-  collection: string,
-  id: string,
-  vector: number[],
-  payload: Record<string, unknown> = {},
-): Promise<void> {
-  const client = getQdrantClient();
-  await client.upsert(prefixed(collection), {
-    points: [{ id: toUUID(id), vector, payload: { ...payload, _id: id } }],
-  });
-}
-
-export async function deleteVector(
-  collection: string,
-  id: string,
-): Promise<void> {
-  const client = getQdrantClient();
-  await client.delete(prefixed(collection), {
-    points: [toUUID(id)],
-  });
-}
-
-export interface VectorSearchResult {
-  id: string;
-  score: number;
-}
-
-export async function searchVectors(
-  collection: string,
-  vector: number[],
-  limit: number,
-): Promise<VectorSearchResult[]> {
-  const client = getQdrantClient();
-  const results = await client.search(prefixed(collection), {
-    vector,
-    limit,
-    with_payload: true,
-  });
-  return results.map((r) => ({
-    id: String((r.payload as Record<string, unknown>)?._id ?? r.id),
-    score: r.score,
-  }));
-}

package/src/server/Storage.ts

@@ -1,135 +0,0 @@
-import {
-  CopyObjectCommand,
-  DeleteObjectCommand,
-  PutObjectCommand,
-  S3Client,
-} from '@aws-sdk/client-s3';
-import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
-
-let _storagePrefix = '';
-
-export function setStoragePrefix(prefix: string): void {
-  _storagePrefix = prefix;
-}
-
-function prefixKey(key: string): string {
-  return _storagePrefix ? `${_storagePrefix}/${key}` : key;
-}
-
-function isDev(): boolean {
-  return process.env.NODE_ENV !== 'production';
-}
-
-function getS3Client(): S3Client {
-  // Always connect to localhost:9000 — MinIO in dev, sidecar R2 proxy in prod.
-  // The sidecar handles R2 auth and bucket isolation transparently.
-  return new S3Client({
-    region: 'us-east-1',
-    endpoint: process.env['MINIO_ENDPOINT'] ?? 'http://localhost:9000',
-    credentials: { accessKeyId: 'minioadmin', secretAccessKey: 'minioadmin' },
-    forcePathStyle: true,
-    requestChecksumCalculation: 'WHEN_REQUIRED',
-    responseChecksumValidation: 'WHEN_REQUIRED',
-  });
-}
-
-function getBucketName(bucket: 'public' | 'temp'): string {
-  return bucket;
-}
-
-function getBaseUrl(bucket: 'public' | 'temp'): string {
-  if (isDev()) {
-    const endpoint = process.env['MINIO_ENDPOINT'] ?? 'http://localhost:9000';
-    return `${endpoint}/${bucket}/`;
-  }
-  // In production, the sidecar injects STORAGE_PUBLIC_URL / STORAGE_TEMP_URL
-  const url = bucket === 'public'
-    ? process.env['STORAGE_PUBLIC_URL']
-    : process.env['STORAGE_TEMP_URL'];
-  if (!url) {
-    // Fall back to sidecar endpoint if URLs not injected
-    const endpoint = process.env['MINIO_ENDPOINT'] ?? 'http://localhost:9000';
-    return `${endpoint}/${bucket}/`;
-  }
-  return url.endsWith('/') ? url : url + '/';
-}
-
-export interface StorageClient {
-  put(
-    bucket: 'public' | 'temp',
-    key: string,
-    body: Buffer,
-    contentType: string,
-  ): Promise<string>;
-  moveToPublic(tempKey: string, destKey: string): Promise<string>;
-  url(bucket: 'public' | 'temp', key: string): string;
-  presignedPut(
-    bucket: 'temp',
-    key: string,
-  ): Promise<{ uploadUrl: string; resultUrl: string }>;
-}
-
-/**
- * Creates a storage client backed by MinIO (dev) or the sidecar R2 proxy (production).
- * Both listen on localhost:9000 — the sidecar handles R2 auth and bucket isolation.
- */
-export function createStorageClient(): StorageClient {
-  const s3 = getS3Client();
-
-  return {
-    async put(bucket, key, body, contentType) {
-      const effectiveKey = prefixKey(key);
-      await s3.send(
-        new PutObjectCommand({
-          Bucket: getBucketName(bucket),
-          Key: effectiveKey,
-          Body: body,
-          ContentType: contentType,
-        }),
-      );
-      return getBaseUrl(bucket) + effectiveKey;
-    },
-
-    async moveToPublic(tempKey, destKey) {
-      const srcBucket = getBucketName('temp');
-      const destBucket = getBucketName('public');
-      const effectiveTempKey = prefixKey(tempKey);
-      const effectiveDestKey = prefixKey(destKey);
-      await s3.send(
-        new CopyObjectCommand({
-          CopySource: `${srcBucket}/${effectiveTempKey}`,
-          Bucket: destBucket,
-          Key: effectiveDestKey,
-        }),
-      );
-      await s3.send(
-        new DeleteObjectCommand({ Bucket: srcBucket, Key: effectiveTempKey }),
-      );
-      return getBaseUrl('public') + effectiveDestKey;
-    },
-
-    url(bucket, key) {
-      return getBaseUrl(bucket) + prefixKey(key);
-    },
-
-    async presignedPut(bucket, key) {
-      const effectiveKey = prefixKey(key);
-      const command = new PutObjectCommand({
-        Bucket: getBucketName(bucket),
-        Key: effectiveKey,
-      });
-      const uploadUrl = await getSignedUrl(s3, command, { expiresIn: 3600 });
-
-      // In dev, rewrite the presigned URL to go through the Express proxy
-      // so the browser doesn't hit a cross-origin S3 endpoint (CORS blocked).
-      let proxiedUploadUrl = uploadUrl;
-      if (isDev()) {
-        const parsed = new URL(uploadUrl);
-        proxiedUploadUrl = `/_s3${parsed.pathname}${parsed.search}`;
-      }
-
-      const resultUrl = getBaseUrl(bucket) + effectiveKey;
-      return { uploadUrl: proxiedUploadUrl, resultUrl };
-    },
-  };
-}