ugly-app 0.1.310 → 0.1.312

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