@edge-base/server 0.1.1

package/src/__tests__/error-format.test.ts

@@ -0,0 +1,250 @@
+/**
+ * 서버 단위 테스트 — lib/errors.ts + RoomsDO pure logic
+ * 1-26 error-format.test.ts — 40개
+ *
+ * 실행: cd packages/server && npx vitest run src/__tests__/error-format.test.ts
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  validationError,
+  unauthorizedError,
+  forbiddenError,
+  notFoundError,
+  methodNotAllowedError,
+  rateLimitError,
+  hookRejectedError,
+  normalizeDatabaseError,
+} from '../lib/errors.js';
+import { EdgeBaseError } from '@edge-base/shared';
+
+// ─── A. EdgeBaseError 구조 ─────────────────────────────────────────────────────
+
+describe('EdgeBaseError structure', () => {
+  it('is an instanceof Error', () => {
+    const err = new EdgeBaseError(400, 'Bad request');
+    expect(err).toBeInstanceOf(Error);
+  });
+
+  it('is an instanceof EdgeBaseError', () => {
+    const err = new EdgeBaseError(400, 'Bad request');
+    expect(err).toBeInstanceOf(EdgeBaseError);
+  });
+
+  it('code stored correctly', () => {
+    const err = new EdgeBaseError(404, 'Not found');
+    expect(err.code).toBe(404);
+  });
+
+  it('message stored correctly', () => {
+    const err = new EdgeBaseError(400, 'Validation failed');
+    expect(err.message).toBe('Validation failed');
+  });
+
+  it('name is "EdgeBaseError"', () => {
+    const err = new EdgeBaseError(500, 'Internal error');
+    expect(err.name).toBe('EdgeBaseError');
+  });
+
+  it('stack is present (runtime-generated)', () => {
+    const err = new EdgeBaseError(500, 'Internal error');
+    // Stack should be present (set by Error constructor)
+    expect(typeof err.stack).toBe('string');
+  });
+});
+
+// ─── B. Error helper factory functions ────────────────────────────────────────
+
+describe('validationError', () => {
+  it('returns status 400', () => {
+    expect(validationError('Bad input').code).toBe(400);
+  });
+
+  it('stores message', () => {
+    expect(validationError('Required fields missing').message).toBe('Required fields missing');
+  });
+
+  it('instanceof EdgeBaseError', () => {
+    expect(validationError('x')).toBeInstanceOf(EdgeBaseError);
+  });
+
+  it('with field errors', () => {
+    const err = validationError('Validation failed', {
+      email: { message: 'Invalid email', code: 'invalid_email' },
+    });
+    expect(err.code).toBe(400);
+    expect(err.message).toBe('Validation failed');
+  });
+});
+
+describe('unauthorizedError', () => {
+  it('returns status 401', () => {
+    expect(unauthorizedError().code).toBe(401);
+  });
+
+  it('default message', () => {
+    expect(unauthorizedError().message).toBe('Unauthorized.');
+  });
+
+  it('custom message', () => {
+    expect(unauthorizedError('Token expired').message).toBe('Token expired');
+  });
+});
+
+describe('forbiddenError', () => {
+  it('returns status 403', () => {
+    expect(forbiddenError().code).toBe(403);
+  });
+
+  it('default message', () => {
+    expect(forbiddenError().message).toBe('Access denied.');
+  });
+
+  it('custom message', () => {
+    expect(forbiddenError('Service Key required').message).toBe('Service Key required');
+  });
+});
+
+describe('notFoundError', () => {
+  it('returns status 404', () => {
+    expect(notFoundError().code).toBe(404);
+  });
+
+  it('default message', () => {
+    expect(notFoundError().message).toBe('Not found.');
+  });
+
+  it('custom message', () => {
+    expect(notFoundError('Record not found').message).toBe('Record not found');
+  });
+});
+
+describe('methodNotAllowedError', () => {
+  it('returns status 405', () => {
+    expect(methodNotAllowedError().code).toBe(405);
+  });
+
+  it('default message', () => {
+    expect(methodNotAllowedError().message).toBe('Method not allowed.');
+  });
+
+  it('custom message', () => {
+    expect(methodNotAllowedError('Custom not allowed message').message).toBe('Custom not allowed message');
+  });
+});
+
+describe('rateLimitError', () => {
+  it('returns status 429', () => {
+    expect(rateLimitError(30).code).toBe(429);
+  });
+
+  it('includes retryAfter in message', () => {
+    expect(rateLimitError(60).message).toContain('60');
+  });
+
+  it('different retryAfter values', () => {
+    expect(rateLimitError(5).message).toContain('5');
+    expect(rateLimitError(3600).message).toContain('3600');
+  });
+});
+
+describe('hookRejectedError', () => {
+  it('passes EdgeBaseError instances through untouched', () => {
+    const original = forbiddenError('Already normalized');
+    expect(hookRejectedError(original)).toBe(original);
+  });
+
+  it('maps ownership denial messages to 403', () => {
+    const err = hookRejectedError(new Error('Only owners can update this record.'));
+    expect(err.code).toBe(403);
+    expect(err.message).toContain('Only owners');
+  });
+
+  it('maps blocked hook messages to 403', () => {
+    const err = hookRejectedError(new Error('Blocked by test beforeUpload'));
+    expect(err.code).toBe(403);
+    expect(err.message).toContain('Blocked by test beforeUpload');
+  });
+
+  it('maps conflict-style messages to 409', () => {
+    const err = hookRejectedError(new Error('Email already exists.'));
+    expect(err.code).toBe(409);
+  });
+
+  it('falls back to validation errors for unknown hook failures', () => {
+    const err = hookRejectedError(new Error('Custom hook failure.'));
+    expect(err.code).toBe(400);
+    expect(err.message).toBe('Custom hook failure.');
+  });
+});
+
+describe('normalizeDatabaseError', () => {
+  it('maps foreign key failures to validation errors', () => {
+    const err = normalizeDatabaseError(new Error('D1_ERROR: FOREIGN KEY constraint failed: SQLITE_CONSTRAINT'));
+    expect(err).toBeInstanceOf(EdgeBaseError);
+    expect(err?.code).toBe(400);
+    expect(err?.message).toContain('Referenced record does not exist');
+    expect(err?.slug).toBe('foreign-key-failed');
+  });
+
+  it('maps foreign key failures from cross-realm error-like objects', () => {
+    const err = normalizeDatabaseError({
+      message: 'D1_ERROR: FOREIGN KEY constraint failed: SQLITE_CONSTRAINT',
+    });
+    expect(err).toBeInstanceOf(EdgeBaseError);
+    expect(err?.code).toBe(400);
+  });
+
+  it('maps unique constraint failures to conflict errors', () => {
+    const err = normalizeDatabaseError(new Error('UNIQUE constraint failed: categories.name'));
+    expect(err).toBeInstanceOf(EdgeBaseError);
+    expect(err?.code).toBe(409);
+    expect(err?.message).toContain('Record already exists');
+    expect(err?.message).toContain("'name'");
+    expect(err?.slug).toBe('record-already-exists');
+  });
+
+  it('returns null for unrelated runtime errors', () => {
+    expect(normalizeDatabaseError(new Error('socket hang up'))).toBeNull();
+  });
+});
+
+// ─── C. Error 구조 직렬화 ────────────────────────────────────────────────────
+
+describe('error JSON structure', () => {
+  it('EdgeBaseError has code + message accessible', () => {
+    const err = new EdgeBaseError(401, 'Not authenticated');
+    const serialized = {
+      code: err.code,
+      message: err.message,
+    };
+    expect(serialized).toEqual({ code: 401, message: 'Not authenticated' });
+  });
+
+  it('stack trace not exposed in serialized form', () => {
+    const err = new EdgeBaseError(500, 'Internal');
+    const json = { code: err.code, message: err.message };
+    // Confirm stack is not in the response body
+    expect(json).not.toHaveProperty('stack');
+  });
+
+  it('400 errors are distinct from 500s', () => {
+    const e400 = validationError('Bad input');
+    const e500 = new EdgeBaseError(500, 'Internal');
+    expect(e400.code).not.toBe(e500.code);
+  });
+
+  it('all helper-created errors are EdgeBaseError instances', () => {
+    const errors = [
+      validationError('x'),
+      unauthorizedError(),
+      forbiddenError(),
+      notFoundError(),
+      methodNotAllowedError(),
+      rateLimitError(10),
+    ];
+    for (const err of errors) {
+      expect(err).toBeInstanceOf(EdgeBaseError);
+    }
+  });
+});

package/src/__tests__/field-ops.test.ts

@@ -0,0 +1,242 @@
+/**
+ * 서버 단위 테스트 — lib/op-parser.ts
+ * 1-07 field-ops.test.ts — 40개
+ *
+ * 실행: cd packages/server && npx vitest run src/__tests__/field-ops.test.ts
+ *
+ * 테스트 대상 (op-parser.ts):
+ *   parseUpdateBody — increment / deleteField / 일반 값 / 혼합 / 에러
+ *   buildOpClause (indirect through parseUpdateBody)
+ */
+
+import { describe, it, expect } from 'vitest';
+import { parseUpdateBody } from '../lib/op-parser.js';
+
+// ─── A. 일반 값 (non-$op) ────────────────────────────────────────────────────
+
+describe('parseUpdateBody — regular values', () => {
+  it('single string field', () => {
+    const { setClauses, params } = parseUpdateBody({ title: 'Hello' });
+    expect(setClauses).toEqual(['"title" = ?']);
+    expect(params).toEqual(['Hello']);
+  });
+
+  it('single number field', () => {
+    const { setClauses, params } = parseUpdateBody({ views: 42 });
+    expect(setClauses).toEqual(['"views" = ?']);
+    expect(params).toEqual([42]);
+  });
+
+  it('null value → field = NULL via regular path', () => {
+    const { setClauses, params } = parseUpdateBody({ deletedAt: null });
+    expect(setClauses).toContain('"deletedAt" = ?');
+    expect(params).toContain(null);
+  });
+
+  it('boolean value', () => {
+    const { setClauses: _setClauses, params } = parseUpdateBody({ active: true });
+    expect(params).toContain(true);
+  });
+
+  it('excludes id field by default', () => {
+    const { setClauses, params } = parseUpdateBody({ id: 'ignored', title: 'kept' });
+    expect(setClauses).toHaveLength(1);
+    expect(setClauses[0]).toContain('"title"');
+    expect(params).toEqual(['kept']);
+  });
+
+  it('excludes custom excludeFields', () => {
+    const { setClauses } = parseUpdateBody(
+      { createdAt: 'now', title: 'hi' },
+      ['id', 'createdAt'],
+    );
+    expect(setClauses).toHaveLength(1);
+    expect(setClauses[0]).toContain('"title"');
+  });
+
+  it('multiple fields → multiple setClauses', () => {
+    const { setClauses, params } = parseUpdateBody({ a: 1, b: 2 });
+    expect(setClauses).toHaveLength(2);
+    expect(params).toEqual([1, 2]);
+  });
+
+  it('empty object → empty setClauses', () => {
+    const { setClauses, params } = parseUpdateBody({});
+    expect(setClauses).toEqual([]);
+    expect(params).toEqual([]);
+  });
+
+  it('field name with special chars is escaped', () => {
+    const { setClauses } = parseUpdateBody({ 'my-field': 'value' });
+    // Should be double-quoted
+    expect(setClauses[0]).toContain('"my-field"');
+  });
+
+  it('field name with double quote is escaped', () => {
+    const { setClauses } = parseUpdateBody({ 'col"name': 'v' });
+    expect(setClauses[0]).toContain('"col""name"');
+  });
+});
+
+// ─── B. increment $op ──────────────────────────────────────────────────────
+
+describe('parseUpdateBody — increment', () => {
+  it('increment generates COALESCE SQL', () => {
+    const { setClauses, params } = parseUpdateBody({
+      viewCount: { $op: 'increment', value: 5 },
+    });
+    expect(setClauses[0]).toBe('"viewCount" = COALESCE("viewCount", 0) + ?');
+    expect(params[0]).toBe(5);
+  });
+
+  it('increment negative value', () => {
+    const { setClauses: _setClauses, params } = parseUpdateBody({
+      score: { $op: 'increment', value: -10 },
+    });
+    expect(params[0]).toBe(-10);
+  });
+
+  it('increment by 0', () => {
+    const { params } = parseUpdateBody({ count: { $op: 'increment', value: 0 } });
+    expect(params[0]).toBe(0);
+  });
+
+  it('increment decimal value', () => {
+    const { params } = parseUpdateBody({ price: { $op: 'increment', value: 3.14 } });
+    expect(params[0]).toBe(3.14);
+  });
+
+  it('increment with no value → defaults to 0', () => {
+    // op-parser: op.value ?? 0
+    const { params } = parseUpdateBody({ count: { $op: 'increment' } } as any);
+    expect(params[0]).toBe(0);
+  });
+
+  it('COALESCE pattern protects against NULL field', () => {
+    const { setClauses } = parseUpdateBody({ n: { $op: 'increment', value: 1 } });
+    expect(setClauses[0]).toContain('COALESCE');
+  });
+
+  it('postgres dialect uses numbered placeholders', () => {
+    const { setClauses, params, nextParamIndex } = parseUpdateBody(
+      { viewCount: { $op: 'increment', value: 5 } },
+      ['id'],
+      { dialect: 'postgres', startIndex: 3 },
+    );
+    expect(setClauses[0]).toBe('"viewCount" = COALESCE("viewCount", 0) + $3');
+    expect(params).toEqual([5]);
+    expect(nextParamIndex).toBe(4);
+  });
+});
+
+// ─── C. deleteField $op ────────────────────────────────────────────────────
+
+describe('parseUpdateBody — deleteField', () => {
+  it('deleteField generates field = NULL', () => {
+    const { setClauses, params } = parseUpdateBody({
+      avatar: { $op: 'deleteField' },
+    });
+    expect(setClauses[0]).toBe('"avatar" = NULL');
+    expect(params).toEqual([]);
+  });
+
+  it('deleteField has no params', () => {
+    const { params } = parseUpdateBody({ x: { $op: 'deleteField' } });
+    expect(params).toHaveLength(0);
+  });
+
+  it('multiple deleteField ops', () => {
+    const { setClauses } = parseUpdateBody({
+      a: { $op: 'deleteField' },
+      b: { $op: 'deleteField' },
+    });
+    expect(setClauses).toHaveLength(2);
+    expect(setClauses.every((c) => c.endsWith('= NULL'))).toBe(true);
+  });
+});
+
+// ─── D. unknown $op ──────────────────────────────────────────────────────
+
+describe('parseUpdateBody — unknown $op', () => {
+  it('unknown $op → throws', () => {
+    expect(() =>
+      parseUpdateBody({ x: { $op: 'multiply', value: 3 } } as any),
+    ).toThrow("Unknown field operator 'multiply'. Supported operators: increment, deleteField.");
+  });
+
+  it('unknown $op error contains op name', () => {
+    try {
+      parseUpdateBody({ x: { $op: 'badOp' } } as any);
+    } catch (err) {
+      expect((err as Error).message).toContain('badOp');
+    }
+  });
+});
+
+// ─── E. 혼합 (mix regular + $op) ─────────────────────────────────────────────
+
+describe('parseUpdateBody — mixed', () => {
+  it('regular + increment mixed', () => {
+    const { setClauses, params: _params } = parseUpdateBody({
+      title: 'New Title',
+      viewCount: { $op: 'increment', value: 1 },
+    });
+    expect(setClauses).toHaveLength(2);
+    const titleClause = setClauses.find((c) => c.includes('"title"'));
+    const viewClause = setClauses.find((c) => c.includes('COALESCE'));
+    expect(titleClause).toBeTruthy();
+    expect(viewClause).toBeTruthy();
+  });
+
+  it('increment + deleteField mixed', () => {
+    const { setClauses } = parseUpdateBody({
+      count: { $op: 'increment', value: 5 },
+      avatar: { $op: 'deleteField' },
+    });
+    expect(setClauses).toHaveLength(2);
+  });
+
+  it('id excluded but $op fields processed', () => {
+    const { setClauses } = parseUpdateBody({
+      id: 'excluded',
+      views: { $op: 'increment', value: 1 },
+    });
+    expect(setClauses).toHaveLength(1);
+    expect(setClauses[0]).toContain('COALESCE');
+  });
+
+  it('postgres dialect preserves numbering across regular + deleteField', () => {
+    const { setClauses, params, nextParamIndex } = parseUpdateBody(
+      {
+        title: 'New Title',
+        avatar: { $op: 'deleteField' },
+      },
+      ['id'],
+      { dialect: 'postgres', startIndex: 2 },
+    );
+    expect(setClauses).toEqual(['"title" = $2', '"avatar" = NULL']);
+    expect(params).toEqual(['New Title']);
+    expect(nextParamIndex).toBe(3);
+  });
+});
+
+// ─── F. isOpObject detection ─────────────────────────────────────────────────
+
+describe('parseUpdateBody — $op marker detection', () => {
+  it('plain object without $op is not treated as op', () => {
+    const { setClauses, params } = parseUpdateBody({ meta: { foo: 'bar' } });
+    // Without $op, it should be treated as regular JSON value
+    expect(setClauses[0]).toBe('"meta" = ?');
+    expect(params[0]).toEqual({ foo: 'bar' });
+  });
+
+  it('null value is not an op object', () => {
+    const { setClauses } = parseUpdateBody({ x: null });
+    expect(setClauses[0]).toBe('"x" = ?');
+  });
+
+  it('array value is not an op object', () => {
+    const { setClauses } = parseUpdateBody({ tags: ['a', 'b'] });
+    expect(setClauses[0]).toBe('"tags" = ?');
+  });
+});