@proteinjs/db-file 1.4.15 → 1.5.1

package/test/FileTestEnvironment.ts

@@ -0,0 +1,118 @@
+import { Db, Table, getDbAsSystem } from '@proteinjs/db';
+import { SpannerDriver } from '@proteinjs/db-driver-spanner';
+import { SpannerEmulatorProvisioner, getDropTestTable } from '@proteinjs/db-driver-spanner/test';
+import { Session, type SessionData, type SessionDataStorage } from '@proteinjs/server-api';
+import { SourceRepository } from '@proteinjs/reflection';
+import { tables as userTables, User, UserRepo } from '@proteinjs/user';
+import { tables as fileTables } from '../src/tables/tables';
+import { FileStorage } from '../src/FileStorage';
+import { FileStorageDriver } from '../src/FileStorageDriver';
+import { FileStorageTableWatcher } from '../src/FileStorageTableWatcher';
+
+/** In-memory SessionDataStorage seeded into the SourceRepository cache (tests don't load the
+ *  generated source graph, so `Session` would otherwise find no implementation). */
+class TestSessionDataStorage implements SessionDataStorage {
+  environment = 'node' as const;
+  private static data: SessionData;
+
+  setData(data: SessionData) {
+    TestSessionDataStorage.data = data;
+  }
+
+  getData(): SessionData {
+    return TestSessionDataStorage.data;
+  }
+}
+
+type SourceRepositoryInternals = { objectCache: Record<string, unknown[]> };
+type FileStorageInternals = { driver?: FileStorageDriver };
+
+/**
+ * Emulator-backed test environment for db-file integration tests (Spanner emulator on
+ * SPANNER_EMULATOR_HOST, provisioned on demand). Same shape as user-server's
+ * UserServerTestEnvironment: seed deterministic session storage + db driver + file storage driver
+ * into the SourceRepository cache, load the tables the suites touch, drop them on the way out.
+ */
+export class FileTestEnvironment {
+  readonly spannerDriver = new SpannerDriver({
+    projectId: 'proteinjs-test',
+    instanceName: 'proteinjs-test',
+    databaseName: 'test',
+  });
+  private dropTestTable = getDropTestTable(this.spannerDriver);
+  private userRepo = new UserRepo();
+
+  async beforeAll() {
+    // The emulator wipes its in-memory instances on any container restart (and CI service
+    // containers start empty) — self-provision so suites never depend on out-of-band setup.
+    await SpannerEmulatorProvisioner.ensureProvisioned({
+      projectId: 'proteinjs-test',
+      instanceName: 'proteinjs-test',
+      databaseName: 'test',
+    });
+    const objectCache = this.objectCache();
+    objectCache['@proteinjs/server-api/SessionDataStorage'] = [new TestSessionDataStorage()];
+    objectCache['@proteinjs/db/DefaultDbDriverFactory'] = [{ getDbDriver: () => this.spannerDriver }];
+    // Tests import src directly (no generated source graph), so the table registry that
+    // cascade machinery resolves through (`tableByName`) must be seeded explicitly.
+    objectCache['@proteinjs/db/Table'] = [...Object.values(userTables), ...Object.values(fileTables)] as unknown[];
+    // The byte-deletion seam under test: prod loads it from the generated source graph.
+    objectCache['@proteinjs/db/TableWatcher'] = [new FileStorageTableWatcher()];
+    Session.setData({
+      sessionId: 'test-session',
+      user: 'guest',
+      data: {},
+    });
+
+    await this.loadTables(userTables);
+    await this.loadTables(fileTables);
+  }
+
+  async afterAll() {
+    await this.dropTables(fileTables);
+    await this.dropTables(userTables);
+    SpannerEmulatorProvisioner.release();
+  }
+
+  /**
+   * Make `driver` the resolved FileStorageDriver: seeds the DefaultFileStorageDriverFactory the
+   * driver resolution reads and clears the cached instance so the next resolution re-reads it.
+   */
+  setDriver(driver: FileStorageDriver) {
+    this.objectCache()['@proteinjs/db-file/DefaultFileStorageDriverFactory'] = [{ getDriver: () => driver }];
+    (FileStorage as unknown as FileStorageInternals).driver = undefined;
+  }
+
+  /** Insert a user row (as system) and return it. */
+  async createUser(args: { name: string; email: string; roles?: string[] }): Promise<User> {
+    return await getDbAsSystem().insert(userTables.User, {
+      name: args.name,
+      email: args.email,
+      password: 'test',
+      emailVerified: true,
+      roles: args.roles ?? [],
+    });
+  }
+
+  /** Seed the session cache with `user` — the identity service calls and scoped db ops run under. */
+  actAs(user: User) {
+    this.userRepo.setUser(user);
+  }
+
+  private objectCache(): Record<string, unknown[]> {
+    return (SourceRepository.get() as unknown as SourceRepositoryInternals).objectCache;
+  }
+
+  private async loadTables(tables: { [key: string]: Table<any> }) {
+    const dbDriver = Db.getDefaultDbDriver();
+    for (const table of Object.values(tables)) {
+      await dbDriver.getTableManager().loadTable(table);
+    }
+  }
+
+  private async dropTables(tables: { [key: string]: Table<any> }) {
+    for (const table of Object.values(tables)) {
+      await this.dropTestTable(table);
+    }
+  }
+}

package/test/GetFileRoute.test.ts

@@ -0,0 +1,258 @@
+import * as http from 'http';
+import { AddressInfo } from 'net';
+import { SourceRepository } from '@proteinjs/reflection';
+import { UserAuth, UserRepo, guestUser, User } from '@proteinjs/user';
+import { File } from '../src/tables/FileTable';
+import { FileStorage } from '../src/FileStorage';
+import { FileStorageDriver } from '../src/FileStorageDriver';
+import { getFile } from '../src/routes/getFile';
+import { FileTestEnvironment } from './FileTestEnvironment';
+
+/** Every byte value once — a payload that corrupts under any text/base64 mix-up. */
+const rawBytes = Buffer.from(Array.from({ length: 256 }, (_, i) => i));
+
+/**
+ * In-memory byte store shaped like the GoogleCloudStorageDriver WITHOUT signed-URL support:
+ * the proxy-serving case (DbFileStorageDriver shape). Stores true bytes at rest per the driver
+ * contract; the interface strings are base64.
+ */
+class TestProxyFileStorageDriver implements FileStorageDriver {
+  readonly store = new Map<string, Buffer>();
+
+  async createFile(file: File, fileData: string): Promise<void> {
+    this.store.set(file.id, Buffer.from(fileData, 'base64'));
+  }
+
+  async getFileData(fileId: string): Promise<string> {
+    const data = this.store.get(fileId);
+    if (data === undefined) {
+      throw new Error(`No such object: ${fileId}`);
+    }
+    return data.toString('base64');
+  }
+
+  async updateFileData(fileId: string, data: string): Promise<void> {
+    this.store.set(fileId, Buffer.from(data, 'base64'));
+  }
+
+  async deleteFile(fileId: string): Promise<void> {
+    this.store.delete(fileId);
+  }
+}
+
+/**
+ * Local GCS shim: the signed-URL serving case. Blobs live as TRUE bytes behind a real local HTTP
+ * server (as they do in GCS); `getSignedUrl` mints a URL into that server's URL space, and
+ * clients read the bytes directly from it — exactly the redirect flow the route implements.
+ */
+class TestSignedUrlFileStorageDriver implements FileStorageDriver {
+  readonly store = new Map<string, { bytes: Buffer; contentType: string }>();
+  private server?: http.Server;
+  private port?: number;
+
+  async start(): Promise<void> {
+    this.server = http.createServer((req, res) => {
+      const fileId = (req.url ?? '').replace(/^\/blob\//, '').split('?')[0];
+      const blob = this.store.get(fileId);
+      if (!blob) {
+        res.writeHead(404).end();
+        return;
+      }
+      res.writeHead(200, { 'Content-Type': blob.contentType, 'Content-Length': blob.bytes.length });
+      res.end(blob.bytes);
+    });
+    await new Promise<void>((resolve) => this.server!.listen(0, '127.0.0.1', resolve));
+    this.port = (this.server!.address() as AddressInfo).port;
+  }
+
+  async stop(): Promise<void> {
+    if (this.server) {
+      await new Promise<void>((resolve, reject) => this.server!.close((err) => (err ? reject(err) : resolve())));
+    }
+  }
+
+  async createFile(file: File, fileData: string): Promise<void> {
+    this.store.set(file.id, { bytes: Buffer.from(fileData, 'base64'), contentType: file.type });
+  }
+
+  async getFileData(fileId: string): Promise<string> {
+    const blob = this.store.get(fileId);
+    if (blob === undefined) {
+      throw new Error(`No such object: ${fileId}`);
+    }
+    return blob.bytes.toString('base64');
+  }
+
+  async updateFileData(fileId: string, data: string): Promise<void> {
+    const existing = this.store.get(fileId);
+    this.store.set(fileId, {
+      bytes: Buffer.from(data, 'base64'),
+      contentType: existing?.contentType ?? 'application/octet-stream',
+    });
+  }
+
+  async getSignedUrl(fileId: string, options?: { ttlMs?: number }): Promise<string> {
+    const expires = Date.now() + (options?.ttlMs ?? 15 * 60 * 1000);
+    return `http://127.0.0.1:${this.port}/blob/${fileId}?sig=test&expires=${expires}`;
+  }
+
+  async deleteFile(fileId: string): Promise<void> {
+    this.store.delete(fileId);
+  }
+}
+
+/** Minimal express Response recorder — the route only touches these members. */
+class ResponseRecorder {
+  statusCode?: number;
+  body?: unknown;
+  redirectUrl?: string;
+  headers: Record<string, string> = {};
+
+  status(code: number): ResponseRecorder {
+    this.statusCode = code;
+    return this;
+  }
+
+  send(body: unknown): ResponseRecorder {
+    this.body = body;
+    return this;
+  }
+
+  setHeader(name: string, value: string): void {
+    this.headers[name.toLowerCase()] = value;
+  }
+
+  redirect(status: number, url: string): void {
+    this.statusCode = status;
+    this.redirectUrl = url;
+  }
+}
+
+type RouteRequest = Parameters<typeof getFile.onRequest>[0];
+type RouteResponse = Parameters<typeof getFile.onRequest>[1];
+
+const invokeRoute = async (fileId: string): Promise<ResponseRecorder> => {
+  const response = new ResponseRecorder();
+  await getFile.onRequest({ params: { id: fileId } } as unknown as RouteRequest, response as unknown as RouteResponse);
+  return response;
+};
+
+const testEnv = new FileTestEnvironment();
+type UserAuthInternals = { userRepo?: unknown };
+let user: User;
+
+beforeAll(async () => {
+  await testEnv.beforeAll();
+  // The route gates on UserAuth.isLoggedIn(), which resolves its user repo from the source
+  // repository — seed it (tests don't load the generated source graph) and reset the static cache.
+  const objectCache = (SourceRepository.get() as unknown as { objectCache: Record<string, unknown[]> }).objectCache;
+  objectCache['@proteinjs/user-auth/AuthenticatedUserRepo'] = [new UserRepo()];
+  (UserAuth as unknown as UserAuthInternals).userRepo = undefined;
+  user = await testEnv.createUser({ name: 'File owner', email: 'file-owner@test.local' });
+  testEnv.actAs(user);
+});
+
+afterAll(async () => {
+  (UserAuth as unknown as UserAuthInternals).userRepo = undefined;
+  await testEnv.afterAll();
+});
+
+describe('GET /file/:id — proxy serving (driver without signed URLs)', () => {
+  const driver = new TestProxyFileStorageDriver();
+
+  beforeAll(() => {
+    testEnv.setDriver(driver);
+  });
+
+  it('serves a non-image binary byte-identical (video/mp4 round-trip)', async () => {
+    const file = await new FileStorage().createFile(
+      { name: 'clip.mp4', type: 'video/mp4', size: rawBytes.length } as File,
+      rawBytes.toString('base64')
+    );
+
+    const response = await invokeRoute(file.id);
+
+    expect(response.redirectUrl).toBeUndefined();
+    expect(response.headers['content-type']).toEqual('video/mp4');
+    expect(Buffer.isBuffer(response.body)).toBe(true);
+    expect(Buffer.compare(response.body as Buffer, rawBytes)).toBe(0);
+  });
+
+  it('still serves images byte-identical (no regression on the decoded-image path)', async () => {
+    const file = await new FileStorage().createFile(
+      { name: 'shot.png', type: 'image/png', size: rawBytes.length } as File,
+      rawBytes.toString('base64')
+    );
+
+    const response = await invokeRoute(file.id);
+
+    expect(Buffer.isBuffer(response.body)).toBe(true);
+    expect(Buffer.compare(response.body as Buffer, rawBytes)).toBe(0);
+  });
+});
+
+describe('GET /file/:id — signed-URL serving (302 redirect)', () => {
+  const driver = new TestSignedUrlFileStorageDriver();
+
+  beforeAll(async () => {
+    await driver.start();
+    testEnv.setDriver(driver);
+  });
+
+  afterAll(async () => {
+    await driver.stop();
+  });
+
+  it('302-redirects to the signed URL; following it yields the true bytes, byte-identical', async () => {
+    const file = await new FileStorage().createFile(
+      { name: 'clip.mp4', type: 'video/mp4', size: rawBytes.length } as File,
+      rawBytes.toString('base64')
+    );
+
+    const response = await invokeRoute(file.id);
+
+    expect(response.statusCode).toEqual(302);
+    expect(response.redirectUrl).toBeDefined();
+
+    const blobResponse = await fetch(response.redirectUrl!);
+    expect(blobResponse.status).toEqual(200);
+    expect(blobResponse.headers.get('content-type')).toEqual('video/mp4');
+    const served = Buffer.from(await blobResponse.arrayBuffer());
+    expect(Buffer.compare(served, rawBytes)).toBe(0);
+  });
+
+  it('caches the redirect briefly so repeated loads reuse one signed URL within its TTL', async () => {
+    const file = await new FileStorage().createFile(
+      { name: 'shot.png', type: 'image/png', size: rawBytes.length } as File,
+      rawBytes.toString('base64')
+    );
+
+    const response = await invokeRoute(file.id);
+
+    expect(response.statusCode).toEqual(302);
+    expect(response.headers['cache-control']).toEqual('private, max-age=300');
+  });
+
+  it('404s on a missing file id without minting a signed URL', async () => {
+    const response = await invokeRoute('00000000-0000-0000-0000-000000000000');
+
+    expect(response.statusCode).toEqual(404);
+    expect(response.redirectUrl).toBeUndefined();
+  });
+
+  it('401s when not logged in, without redirecting or leaking a signed URL', async () => {
+    const file = await new FileStorage().createFile(
+      { name: 'clip.mp4', type: 'video/mp4', size: rawBytes.length } as File,
+      rawBytes.toString('base64')
+    );
+    testEnv.actAs(guestUser as unknown as User);
+    try {
+      const response = await invokeRoute(file.id);
+
+      expect(response.statusCode).toEqual(401);
+      expect(response.redirectUrl).toBeUndefined();
+    } finally {
+      testEnv.actAs(user);
+    }
+  });
+});

package/test/emulatorLock.globalSetup.js

@@ -0,0 +1,11 @@
+'use strict';
+// jest runs this in the main jest process before any test workers (and before setupFiles), so one
+// whole `jest --runInBand` run holds the emulator exclusively — concurrent suites from other
+// packages wait instead of corrupting each other. globalSetup runs before setupFiles, so require
+// ./setup here to compute the same SPANNER_EMULATOR_HOST the tests will use.
+require('./setup');
+const { acquire } = require('./emulatorLock');
+
+module.exports = async () => {
+  await acquire(process.env.SPANNER_EMULATOR_HOST, require('../package.json').name);
+};

package/test/emulatorLock.globalTeardown.js

@@ -0,0 +1,8 @@
+'use strict';
+// Releases the emulator lock acquired by ./emulatorLock.globalSetup.js (same jest parent process).
+require('./setup');
+const { release } = require('./emulatorLock');
+
+module.exports = async () => {
+  release(process.env.SPANNER_EMULATOR_HOST, require('../package.json').name);
+};

package/test/emulatorLock.js

@@ -0,0 +1,124 @@
+'use strict';
+/**
+ * Cross-process mutual exclusion around a Spanner emulator.
+ *
+ * `--runInBand` serializes tests within one package; nothing serializes across packages, and two
+ * jest runs hitting the same emulator corrupt each other (orphaned transactions, DDL
+ * FAILED_PRECONDITION). This lock closes that gap for this package: a lockfile in os.tmpdir()
+ * keyed by the emulator host string, held for the whole jest run via globalSetup/globalTeardown.
+ *
+ * The lockfile PATH FORMULA must stay byte-identical to the fleet's canonical implementation
+ * (`EmulatorLock.lockFilePathFor` in @n3xah/thought-common/test) so suites from every repo
+ * pointed at the same emulator actually contend on the same file. The logic is duplicated here
+ * because this repo sits BELOW @n3xah in the dependency layering (thought-common itself depends
+ * on @proteinjs/user) — future extraction target: @proteinjs/db-driver-spanner/test, beside
+ * SpannerEmulatorProvisioner.
+ */
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const POLL_MS = 1000;
+const WAIT_LOG_EVERY_MS = 30_000;
+const TIMEOUT_MS = 60 * 60_000; // full DB suites elsewhere legitimately run 30+ minutes
+
+/** Deterministic lockfile path for an emulator host — sanitized slug plus short hash. */
+function lockFilePathFor(host) {
+  const slug = host
+    .replace(/[^a-zA-Z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 64);
+  const hash = crypto.createHash('sha1').update(host).digest('hex').slice(0, 8);
+  return path.join(os.tmpdir(), `n3xa-spanner-emulator-${slug}-${hash}.lock`);
+}
+
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === 'EPERM'; // alive but not ours; ESRCH = gone
+  }
+}
+
+function tryCreate(lockFilePath, packageName) {
+  const info = {
+    pid: process.pid,
+    packageName,
+    timestamp: new Date().toISOString(),
+    nonce: crypto.randomBytes(8).toString('hex'),
+  };
+  try {
+    fs.writeFileSync(lockFilePath, JSON.stringify(info), { flag: 'wx' });
+    return true;
+  } catch (error) {
+    if (error.code === 'EEXIST') {
+      return false;
+    }
+    throw error;
+  }
+}
+
+function readLockInfo(lockFilePath) {
+  try {
+    return JSON.parse(fs.readFileSync(lockFilePath, 'utf8'));
+  } catch {
+    return undefined; // gone, or unparseable (treated as stale)
+  }
+}
+
+async function acquire(host, packageName) {
+  const lockFilePath = lockFilePathFor(host);
+  const start = Date.now();
+  let lastWaitLog = 0;
+  for (;;) {
+    if (tryCreate(lockFilePath, packageName)) {
+      return;
+    }
+    const info = readLockInfo(lockFilePath);
+    if (!info || !isPidAlive(info.pid)) {
+      // Stale (crashed run) — remove and retry; the O_EXCL create above decides the winner.
+      try {
+        fs.unlinkSync(lockFilePath);
+      } catch (error) {
+        if (error.code !== 'ENOENT') {
+          throw error;
+        }
+      }
+    } else {
+      const now = Date.now();
+      if (now - start >= TIMEOUT_MS) {
+        throw new Error(
+          `timed out waiting for emulator lock (${host}) held by pid ${info.pid} (${info.packageName}); ` +
+            `lockfile: ${lockFilePath}`
+        );
+      }
+      if (lastWaitLog === 0 || now - lastWaitLog >= WAIT_LOG_EVERY_MS) {
+        console.log(
+          `[${packageName}] waiting for emulator lock (${host}) held by pid ${info.pid} ` +
+            `(${info.packageName}, since ${info.timestamp}) — waited ${Math.round((now - start) / 1000)}s`
+        );
+        lastWaitLog = now;
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, POLL_MS));
+  }
+}
+
+function release(host, packageName) {
+  const lockFilePath = lockFilePathFor(host);
+  const info = readLockInfo(lockFilePath);
+  if (!info) {
+    console.log(`[${packageName}] emulator lock (${host}) was already gone at release`);
+    return;
+  }
+  if (info.pid !== process.pid) {
+    throw new Error(
+      `refusing to release emulator lock (${host}) owned by pid ${info.pid} (${info.packageName}), not us (${process.pid})`
+    );
+  }
+  fs.unlinkSync(lockFilePath);
+}
+
+module.exports = { acquire, release, lockFilePathFor };

package/test/setup.js

@@ -0,0 +1,2 @@
+process.env.SPANNER_EMULATOR_HOST = process.env.SPANNER_EMULATOR_HOST || 'localhost:9010';
+process.env.DB_LOG_LEVEL = 'error';