@proteinjs/user-server 1.5.3 → 1.6.0

package/test/UpdateUserInfoAvatar.test.ts

@@ -0,0 +1,174 @@
+import fs from 'fs';
+import path from 'path';
+import sharp from 'sharp';
+import { getDbAsSystem } from '@proteinjs/db';
+import { FileStorage, File, tables as fileTables } from '@proteinjs/db-file';
+import { tables, UserRepo, getScopedDbAsSystem } from '@proteinjs/user';
+import { UserServerTestEnvironment } from './UserServerTestEnvironment';
+import { UpdateUserInfo } from '../src/services/UpdateUserInfo';
+
+const testEnv = new UserServerTestEnvironment();
+
+/** JPEG magic bytes (SOI + marker prefix). */
+const isJpeg = (buffer: Buffer) => buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff;
+
+const getFileRow = async (fileId: string) => await getScopedDbAsSystem<File>().get(fileTables.File, { id: fileId });
+
+/**
+ * Avatars are photo OR emoji — exactly one active — stored as 512x512 JPEG, previous photo file
+ * deleted on every change, and the server session cache refreshed in the same stroke (the same
+ * helper that fixes the updateName rename-staleness wart). All assertions are outcomes: rows,
+ * bytes, cache reads.
+ */
+describe('UpdateUserInfo avatar mutations', () => {
+  const service = new UpdateUserInfo();
+
+  beforeAll(async () => {
+    await testEnv.beforeAll();
+  });
+
+  afterAll(async () => {
+    await testEnv.afterAll();
+  });
+
+  it('updateAvatarPhoto stores a 512x512 JPEG file and points the user row at it', async () => {
+    const user = await testEnv.createUser({ name: 'Photo user', email: 'photo@test.local' });
+    testEnv.actAs(user);
+    const png = await sharp({
+      create: { width: 800, height: 600, channels: 3, background: { r: 200, g: 80, b: 40 } },
+    })
+      .png()
+      .toBuffer();
+
+    const updated = await service.updateAvatarPhoto(png.toString('base64'), 'image/png');
+
+    // Returned user: photo active, emoji null, no password hash.
+    expect(updated.avatarFileId).toBeTruthy();
+    expect(updated.avatarEmoji).toBeFalsy();
+    expect((updated as any).password).toBeUndefined();
+
+    // User row persisted with the exactly-one invariant.
+    const row = await getDbAsSystem().get(tables.User, { id: user.id });
+    expect(row.avatarFileId).toBe(updated.avatarFileId);
+    expect(row.avatarEmoji).toBeFalsy();
+
+    // File row + bytes written: a real 512x512 JPEG.
+    const file = await getFileRow(row.avatarFileId!);
+    expect(file).toBeTruthy();
+    expect(file.type).toBe('image/jpeg');
+    const bytes = Buffer.from(await new FileStorage().getFileData(file.id), 'base64');
+    expect(isJpeg(bytes)).toBe(true);
+    expect(file.size).toBe(bytes.length);
+    const metadata = await sharp(bytes).metadata();
+    expect(metadata.width).toBe(512);
+    expect(metadata.height).toBe(512);
+
+    // Session cache refreshed in the same stroke.
+    expect(new UserRepo().getUser().avatarFileId).toBe(row.avatarFileId);
+  });
+
+  it('a second updateAvatarPhoto deletes the previous avatar file', async () => {
+    const user = await testEnv.createUser({ name: 'Replacer', email: 'replace@test.local' });
+    testEnv.actAs(user);
+    const png = await sharp({ create: { width: 300, height: 300, channels: 3, background: { r: 0, g: 120, b: 200 } } })
+      .png()
+      .toBuffer();
+
+    const first = await service.updateAvatarPhoto(png.toString('base64'), 'image/png');
+    const second = await service.updateAvatarPhoto(png.toString('base64'), 'image/png');
+    expect(second.avatarFileId).not.toBe(first.avatarFileId);
+
+    // The prior file is gone — row and bytes.
+    expect(await getFileRow(first.avatarFileId!)).toBeFalsy();
+    expect(await new FileStorage().getFileData(first.avatarFileId!)).toBe('');
+    // The new one is intact.
+    expect(await getFileRow(second.avatarFileId!)).toBeTruthy();
+  });
+
+  it('updateAvatarPhoto normalizes HEIC (default iPhone camera format) to JPEG', async () => {
+    const user = await testEnv.createUser({ name: 'iPhone user', email: 'heic@test.local' });
+    testEnv.actAs(user);
+    const heic = fs.readFileSync(path.join(__dirname, 'fixtures', 'fixture.heic'));
+
+    const updated = await service.updateAvatarPhoto(heic.toString('base64'), 'image/heic');
+
+    const bytes = Buffer.from(await new FileStorage().getFileData(updated.avatarFileId!), 'base64');
+    expect(isJpeg(bytes)).toBe(true);
+    const metadata = await sharp(bytes).metadata();
+    expect(metadata.width).toBe(512);
+    expect(metadata.height).toBe(512);
+  });
+
+  it('updateAvatarEmoji sets the emoji, nulls the photo, and deletes the previous photo file', async () => {
+    const user = await testEnv.createUser({ name: 'Emoji user', email: 'emoji@test.local' });
+    testEnv.actAs(user);
+    const png = await sharp({ create: { width: 64, height: 64, channels: 3, background: { r: 9, g: 9, b: 9 } } })
+      .png()
+      .toBuffer();
+    const withPhoto = await service.updateAvatarPhoto(png.toString('base64'), 'image/png');
+
+    const updated = await service.updateAvatarEmoji('🦞');
+
+    // Exactly-one invariant, in the row and the returned user.
+    expect(updated.avatarEmoji).toBe('🦞');
+    expect(updated.avatarFileId).toBeFalsy();
+    const row = await getDbAsSystem().get(tables.User, { id: user.id });
+    expect(row.avatarEmoji).toBe('🦞');
+    expect(row.avatarFileId).toBeFalsy();
+
+    // Previous photo file deleted; session cache refreshed.
+    expect(await getFileRow(withPhoto.avatarFileId!)).toBeFalsy();
+    expect(new UserRepo().getUser().avatarEmoji).toBe('🦞');
+  });
+
+  it('accepts multi-codepoint emoji (ZWJ sequences)', async () => {
+    const user = await testEnv.createUser({ name: 'Astronaut', email: 'zwj@test.local' });
+    testEnv.actAs(user);
+    const updated = await service.updateAvatarEmoji('👩‍🚀');
+    expect(updated.avatarEmoji).toBe('👩‍🚀');
+  });
+
+  it('clearAvatar removes both representations and the stored photo file', async () => {
+    const user = await testEnv.createUser({ name: 'Clearer', email: 'clear@test.local' });
+    testEnv.actAs(user);
+    const png = await sharp({ create: { width: 64, height: 64, channels: 3, background: { r: 1, g: 2, b: 3 } } })
+      .png()
+      .toBuffer();
+    const withPhoto = await service.updateAvatarPhoto(png.toString('base64'), 'image/png');
+
+    const updated = await service.clearAvatar();
+
+    expect(updated.avatarEmoji).toBeFalsy();
+    expect(updated.avatarFileId).toBeFalsy();
+    const row = await getDbAsSystem().get(tables.User, { id: user.id });
+    expect(row.avatarEmoji).toBeFalsy();
+    expect(row.avatarFileId).toBeFalsy();
+    expect(await getFileRow(withPhoto.avatarFileId!)).toBeFalsy();
+    expect(new UserRepo().getUser().avatarFileId).toBeFalsy();
+  });
+
+  it('rejects oversized photos before transforming, and unsupported types', async () => {
+    const user = await testEnv.createUser({ name: 'Rejected', email: 'reject@test.local' });
+    testEnv.actAs(user);
+
+    const oversized = Buffer.alloc(10 * 1024 * 1024 + 1);
+    await expect(service.updateAvatarPhoto(oversized.toString('base64'), 'image/png')).rejects.toThrow(/too large/);
+    await expect(service.updateAvatarPhoto(Buffer.alloc(10).toString('base64'), 'image/gif')).rejects.toThrow(
+      /Unsupported avatar image type/
+    );
+
+    // Neither rejection touched the user row.
+    const row = await getDbAsSystem().get(tables.User, { id: user.id });
+    expect(row.avatarFileId).toBeFalsy();
+    expect(row.avatarEmoji).toBeFalsy();
+  });
+
+  it('rejects non-emoji strings as avatar emoji', async () => {
+    const user = await testEnv.createUser({ name: 'Wordy', email: 'wordy@test.local' });
+    testEnv.actAs(user);
+
+    await expect(service.updateAvatarEmoji('hello')).rejects.toThrow(/single short emoji/);
+    await expect(service.updateAvatarEmoji('')).rejects.toThrow(/single short emoji/);
+    await expect(service.updateAvatarEmoji('🦞🦞🦞🦞🦞🦞🦞🦞🦞')).rejects.toThrow(/single short emoji/);
+  });
+});

package/test/UpdateUserInfoSessionRefresh.test.ts

@@ -0,0 +1,37 @@
+import { getDbAsSystem } from '@proteinjs/db';
+import { tables, UserRepo } from '@proteinjs/user';
+import { UserServerTestEnvironment } from './UserServerTestEnvironment';
+import { UpdateUserInfo } from '../src/services/UpdateUserInfo';
+
+const testEnv = new UserServerTestEnvironment();
+
+/**
+ * The rename-staleness wart, red-before-green: UpdateUserInfo.updateName wrote the DB but never
+ * refreshed the server session cache (userCache serializes the user into session data), so every
+ * read through UserRepo in the same request context — and any long-lived context that keeps its
+ * session data, e.g. socket sessions — kept serving the OLD name until re-login. The fix routes
+ * every user-info mutation through one helper that persists AND refreshes the session cache.
+ */
+describe('UpdateUserInfo.updateName — persists AND refreshes the server session cache', () => {
+  beforeAll(async () => {
+    await testEnv.beforeAll();
+  });
+
+  afterAll(async () => {
+    await testEnv.afterAll();
+  });
+
+  it('updates the user row and the session-cached user in the same stroke', async () => {
+    const user = await testEnv.createUser({ name: 'Old Name', email: 'rename@test.local' });
+    testEnv.actAs(user);
+
+    await new UpdateUserInfo().updateName('New Name');
+
+    // Outcome 1: the row is renamed (held even pre-fix).
+    const row = await getDbAsSystem().get(tables.User, { id: user.id });
+    expect(row.name).toBe('New Name');
+
+    // Outcome 2 (the wart): the session cache must serve the new name too. RED pre-fix.
+    expect(new UserRepo().getUser().name).toBe('New Name');
+  });
+});

package/test/UserServerTestEnvironment.ts

@@ -0,0 +1,97 @@
+import moment from 'moment';
+import { Db, Table, getDbAsSystem } from '@proteinjs/db';
+import { SpannerDriver } from '@proteinjs/db-driver-spanner';
+import { SpannerEmulatorProvisioner, getDropTestTable } from '@proteinjs/db-driver-spanner/test';
+import { tables as fileTables } from '@proteinjs/db-file';
+import { Session, type SessionData, type SessionDataStorage } from '@proteinjs/server-api';
+import { SourceRepository } from '@proteinjs/reflection';
+import { tables as userTables, User, UserRepo } from '@proteinjs/user';
+
+/** 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[]> };
+
+/**
+ * Emulator-backed test environment for user-server integration tests (Spanner emulator on
+ * SPANNER_EMULATOR_HOST, provisioned on demand). Same shape as chat-server's ChatTestEnvironment:
+ * seed deterministic session storage + db driver into the SourceRepository cache, load the tables
+ * the suites touch, drop them on the way out.
+ */
+export class UserServerTestEnvironment {
+  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 = (SourceRepository.get() as unknown as SourceRepositoryInternals).objectCache;
+    objectCache['@proteinjs/server-api/SessionDataStorage'] = [new TestSessionDataStorage()];
+    objectCache['@proteinjs/db/DefaultDbDriverFactory'] = [{ getDbDriver: () => this.spannerDriver }];
+    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();
+  }
+
+  /** 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 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/avatarRoute.test.ts

@@ -0,0 +1,111 @@
+import sharp from 'sharp';
+import { guestUser, avatarRoute } from '@proteinjs/user';
+import { UserServerTestEnvironment } from './UserServerTestEnvironment';
+import { UpdateUserInfo } from '../src/services/UpdateUserInfo';
+import { avatar } from '../src/routes/avatar';
+
+const testEnv = new UserServerTestEnvironment();
+
+/** Captures exactly what the route writes — status, headers, body. */
+class MockResponse {
+  statusCode = 200;
+  headers: Record<string, string> = {};
+  body: any;
+
+  status(code: number) {
+    this.statusCode = code;
+    return this;
+  }
+
+  setHeader(name: string, value: string) {
+    this.headers[name.toLowerCase()] = value;
+  }
+
+  send(body?: any) {
+    this.body = body;
+    return this;
+  }
+}
+
+const requestAvatar = async (userId: string): Promise<MockResponse> => {
+  const response = new MockResponse();
+  await avatar.onRequest({ params: { userId } } as any, response as any);
+  return response;
+};
+
+/**
+ * The shared-visibility door for avatar photos: logged-in users can render ANY user's avatar
+ * (File rows are ScopedRecords, so /file/:id can't serve them cross-user); logged-out requests
+ * get 401; emoji/no-avatar users get 404 (clients render emoji/initials from the user record).
+ * Only the file id stored on the user row is ever served.
+ */
+describe('GET /avatar/:userId', () => {
+  beforeAll(async () => {
+    await testEnv.beforeAll();
+  });
+
+  afterAll(async () => {
+    await testEnv.afterAll();
+  });
+
+  it("serves another user's avatar photo to any logged-in (non-admin) user, cacheable by fileId", async () => {
+    const owner = await testEnv.createUser({ name: 'Owner', email: 'owner@test.local' });
+    testEnv.actAs(owner);
+    const png = await sharp({ create: { width: 100, height: 100, channels: 3, background: { r: 5, g: 150, b: 90 } } })
+      .png()
+      .toBuffer();
+    const updated = await new UpdateUserInfo().updateAvatarPhoto(png.toString('base64'), 'image/png');
+
+    // A DIFFERENT, non-admin user fetches it — the file row is scoped to the owner, so this
+    // only works through the route's narrow system read.
+    const viewer = await testEnv.createUser({ name: 'Viewer', email: 'viewer@test.local', roles: [] });
+    testEnv.actAs(viewer);
+    const response = await requestAvatar(owner.id);
+
+    expect(response.statusCode).toBe(200);
+    expect(response.headers['content-type']).toBe('image/jpeg');
+    expect(response.headers['cache-control']).toBe('public, max-age=86400, immutable');
+    const bytes = response.body as Buffer;
+    expect(Buffer.isBuffer(bytes)).toBe(true);
+    expect(bytes[0]).toBe(0xff); // JPEG SOI
+    expect(bytes[1]).toBe(0xd8);
+    const metadata = await sharp(bytes).metadata();
+    expect(metadata.width).toBe(512);
+    expect(metadata.height).toBe(512);
+
+    // The client-side URL contract carries the cache-buster.
+    expect(avatarRoute.path(owner.id, updated.avatarFileId!)).toBe(`/avatar/${owner.id}?v=${updated.avatarFileId}`);
+  });
+
+  it('404s for an emoji-avatar user and a no-avatar user (photos only)', async () => {
+    const emojiUser = await testEnv.createUser({ name: 'Emoji', email: 'emoji-route@test.local' });
+    testEnv.actAs(emojiUser);
+    await new UpdateUserInfo().updateAvatarEmoji('🦀');
+    const bareUser = await testEnv.createUser({ name: 'Bare', email: 'bare-route@test.local' });
+
+    testEnv.actAs(bareUser);
+    expect((await requestAvatar(emojiUser.id)).statusCode).toBe(404);
+    expect((await requestAvatar(bareUser.id)).statusCode).toBe(404);
+  });
+
+  it('404s for unknown ids — :userId is a keyed lookup, never a path', async () => {
+    const viewer = await testEnv.createUser({ name: 'Curious', email: 'curious@test.local' });
+    testEnv.actAs(viewer);
+    expect((await requestAvatar('no-such-user')).statusCode).toBe(404);
+    expect((await requestAvatar('../../etc/passwd')).statusCode).toBe(404);
+  });
+
+  it('401s without a logged-in session', async () => {
+    const owner = await testEnv.createUser({ name: 'Private', email: 'private@test.local' });
+    testEnv.actAs(owner);
+    const png = await sharp({ create: { width: 32, height: 32, channels: 3, background: { r: 9, g: 9, b: 9 } } })
+      .png()
+      .toBuffer();
+    await new UpdateUserInfo().updateAvatarPhoto(png.toString('base64'), 'image/png');
+
+    testEnv.actAs(guestUser as any);
+    const response = await requestAvatar(owner.id);
+    expect(response.statusCode).toBe(401);
+    expect(response.body).not.toBeInstanceOf(Buffer);
+  });
+});

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/tsconfig.json

@@ -1,5 +1,6 @@
 {
   "compilerOptions": {
+    "noEmitOnError": true,
     "rootDir": "./",
     "target": "es5",
     "module": "commonjs",