@happier-dev/relay-server 0.2.6-dev.1778098335.1 → 0.2.11-preview.3

package/node_modules/@happier-dev/release-runtime/node_modules/yauzl/node_modules/fd-slicer/test/test.js

@@ -0,0 +1,350 @@
+var fdSlicer = require('../');
+var fs = require('fs');
+var crypto = require('crypto');
+var path = require('path');
+var streamEqual = require('stream-equal');
+var assert = require('assert');
+var Pend = require('pend');
+var StreamSink = require('streamsink');
+
+var describe = global.describe;
+var it = global.it;
+var before = global.before;
+var beforeEach = global.beforeEach;
+var after = global.after;
+
+var testBlobFile = path.join(__dirname, "test-blob.bin");
+var testBlobFileSize = 20 * 1024 * 1024;
+var testOutBlobFile = path.join(__dirname, "test-blob-out.bin");
+
+describe("FdSlicer", function() {
+  before(function(done) {
+    var out = fs.createWriteStream(testBlobFile);
+    for (var i = 0; i < testBlobFileSize / 1024; i += 1) {
+      out.write(crypto.pseudoRandomBytes(1024));
+    }
+    out.end();
+    out.on('close', done);
+  });
+  beforeEach(function() {
+    try {
+      fs.unlinkSync(testOutBlobFile);
+    } catch (err) {
+    }
+  });
+  after(function() {
+    try {
+      fs.unlinkSync(testBlobFile);
+      fs.unlinkSync(testOutBlobFile);
+    } catch (err) {
+    }
+  });
+  it("reads a 20MB file (autoClose on)", function(done) {
+    fs.open(testBlobFile, 'r', function(err, fd) {
+      if (err) return done(err);
+      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
+      var actualStream = slicer.createReadStream();
+      var expectedStream = fs.createReadStream(testBlobFile);
+
+      var pend = new Pend();
+      pend.go(function(cb) {
+        slicer.on('close', cb);
+      });
+      pend.go(function(cb) {
+        streamEqual(expectedStream, actualStream, function(err, equal) {
+          if (err) return done(err);
+          assert.ok(equal);
+          cb();
+        });
+      });
+      pend.wait(done);
+    });
+  });
+  it("reads 4 chunks simultaneously", function(done) {
+    fs.open(testBlobFile, 'r', function(err, fd) {
+      if (err) return done(err);
+      var slicer = fdSlicer.createFromFd(fd);
+      var actualPart1 = slicer.createReadStream({start: testBlobFileSize * 0/4, end: testBlobFileSize * 1/4});
+      var actualPart2 = slicer.createReadStream({start: testBlobFileSize * 1/4, end: testBlobFileSize * 2/4});
+      var actualPart3 = slicer.createReadStream({start: testBlobFileSize * 2/4, end: testBlobFileSize * 3/4});
+      var actualPart4 = slicer.createReadStream({start: testBlobFileSize * 3/4, end: testBlobFileSize * 4/4});
+      var expectedPart1 = slicer.createReadStream({start: testBlobFileSize * 0/4, end: testBlobFileSize * 1/4});
+      var expectedPart2 = slicer.createReadStream({start: testBlobFileSize * 1/4, end: testBlobFileSize * 2/4});
+      var expectedPart3 = slicer.createReadStream({start: testBlobFileSize * 2/4, end: testBlobFileSize * 3/4});
+      var expectedPart4 = slicer.createReadStream({start: testBlobFileSize * 3/4, end: testBlobFileSize * 4/4});
+      var pend = new Pend();
+      pend.go(function(cb) {
+        streamEqual(expectedPart1, actualPart1, function(err, equal) {
+          assert.ok(equal);
+          cb(err);
+        });
+      });
+      pend.go(function(cb) {
+        streamEqual(expectedPart2, actualPart2, function(err, equal) {
+          assert.ok(equal);
+          cb(err);
+        });
+      });
+      pend.go(function(cb) {
+        streamEqual(expectedPart3, actualPart3, function(err, equal) {
+          assert.ok(equal);
+          cb(err);
+        });
+      });
+      pend.go(function(cb) {
+        streamEqual(expectedPart4, actualPart4, function(err, equal) {
+          assert.ok(equal);
+          cb(err);
+        });
+      });
+      pend.wait(function(err) {
+        if (err) return done(err);
+        fs.close(fd, done);
+      });
+    });
+  });
+
+  it("writes a 20MB file (autoClose on)", function(done) {
+    fs.open(testOutBlobFile, 'w', function(err, fd) {
+      if (err) return done(err);
+      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
+      var actualStream = slicer.createWriteStream();
+      var inStream = fs.createReadStream(testBlobFile);
+
+      slicer.on('close', function() {
+        var expected = fs.createReadStream(testBlobFile);
+        var actual = fs.createReadStream(testOutBlobFile);
+
+        streamEqual(expected, actual, function(err, equal) {
+          if (err) return done(err);
+          assert.ok(equal);
+          done();
+        });
+      });
+      inStream.pipe(actualStream);
+    });
+  });
+
+  it("writes 4 chunks simultaneously", function(done) {
+    fs.open(testOutBlobFile, 'w', function(err, fd) {
+      if (err) return done(err);
+      var slicer = fdSlicer.createFromFd(fd);
+      var actualPart1 = slicer.createWriteStream({start: testBlobFileSize * 0/4});
+      var actualPart2 = slicer.createWriteStream({start: testBlobFileSize * 1/4});
+      var actualPart3 = slicer.createWriteStream({start: testBlobFileSize * 2/4});
+      var actualPart4 = slicer.createWriteStream({start: testBlobFileSize * 3/4});
+      var in1 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 0/4, end: testBlobFileSize * 1/4});
+      var in2 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 1/4, end: testBlobFileSize * 2/4});
+      var in3 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 2/4, end: testBlobFileSize * 3/4});
+      var in4 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 3/4, end: testBlobFileSize * 4/4});
+      var pend = new Pend();
+      pend.go(function(cb) {
+        actualPart1.on('finish', cb);
+      });
+      pend.go(function(cb) {
+        actualPart2.on('finish', cb);
+      });
+      pend.go(function(cb) {
+        actualPart3.on('finish', cb);
+      });
+      pend.go(function(cb) {
+        actualPart4.on('finish', cb);
+      });
+      in1.pipe(actualPart1);
+      in2.pipe(actualPart2);
+      in3.pipe(actualPart3);
+      in4.pipe(actualPart4);
+      pend.wait(function() {
+        fs.close(fd, function(err) {
+          if (err) return done(err);
+          var expected = fs.createReadStream(testBlobFile);
+          var actual = fs.createReadStream(testOutBlobFile);
+          streamEqual(expected, actual, function(err, equal) {
+            if (err) return done(err);
+            assert.ok(equal);
+            done();
+          });
+        });
+      });
+    });
+  });
+
+  it("throws on invalid ref", function(done) {
+    fs.open(testOutBlobFile, 'w', function(err, fd) {
+      if (err) return done(err);
+      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
+      assert.throws(function() {
+        slicer.unref();
+      }, /invalid unref/);
+      fs.close(fd, done);
+    });
+  });
+
+  it("write stream emits error when max size exceeded", function(done) {
+    fs.open(testOutBlobFile, 'w', function(err, fd) {
+      if (err) return done(err);
+      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
+      var ws = slicer.createWriteStream({start: 0, end: 1000});
+      ws.on('error', function(err) {
+        assert.strictEqual(err.code, 'ETOOBIG');
+        slicer.on('close', done);
+      });
+      ws.end(new Buffer(1001));
+    });
+  });
+
+  it("write stream does not emit error when max size not exceeded", function(done) {
+    fs.open(testOutBlobFile, 'w', function(err, fd) {
+      if (err) return done(err);
+      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
+      var ws = slicer.createWriteStream({end: 1000});
+      slicer.on('close', done);
+      ws.end(new Buffer(1000));
+    });
+  });
+
+  it("write stream start and end work together", function(done) {
+    fs.open(testOutBlobFile, 'w', function(err, fd) {
+      if (err) return done(err);
+      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
+      var ws = slicer.createWriteStream({start: 1, end: 1000});
+      ws.on('error', function(err) {
+        assert.strictEqual(err.code, 'ETOOBIG');
+        slicer.on('close', done);
+      });
+      ws.end(new Buffer(1000));
+    });
+  });
+
+  it("write stream emits progress events", function(done) {
+    fs.open(testOutBlobFile, 'w', function(err, fd) {
+      if (err) return done(err);
+      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
+      var ws = slicer.createWriteStream();
+      var progressEventCount = 0;
+      var prevBytesWritten = 0;
+      ws.on('progress', function() {
+        progressEventCount += 1;
+        assert.ok(ws.bytesWritten > prevBytesWritten);
+        prevBytesWritten = ws.bytesWritten;
+      });
+      slicer.on('close', function() {
+        assert.ok(progressEventCount > 5);
+        done();
+      });
+      for (var i = 0; i < 10; i += 1) {
+        ws.write(new Buffer(16 * 1024 * 2));
+      }
+      ws.end();
+    });
+  });
+
+  it("write stream unrefs when destroyed", function(done) {
+    fs.open(testOutBlobFile, 'w', function(err, fd) {
+      if (err) return done(err);
+      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
+      var ws = slicer.createWriteStream();
+      slicer.on('close', done);
+      ws.write(new Buffer(1000));
+      ws.destroy();
+    });
+  });
+
+  it("read stream unrefs when destroyed", function(done) {
+    fs.open(testBlobFile, 'r', function(err, fd) {
+      if (err) return done(err);
+      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
+      var rs = slicer.createReadStream();
+      rs.on('error', function(err) {
+        assert.strictEqual(err.message, "stream destroyed");
+        slicer.on('close', done);
+      });
+      rs.destroy();
+    });
+  });
+
+  it("fdSlicer.read", function(done) {
+    fs.open(testBlobFile, 'r', function(err, fd) {
+      if (err) return done(err);
+      var slicer = fdSlicer.createFromFd(fd);
+      var outBuf = new Buffer(1024);
+      slicer.read(outBuf, 0, 10, 0, function(err, bytesRead, buf) {
+        assert.strictEqual(bytesRead, 10);
+        fs.close(fd, done);
+      });
+    });
+  });
+
+  it("fdSlicer.write", function(done) {
+    fs.open(testOutBlobFile, 'w', function(err, fd) {
+      if (err) return done(err);
+      var slicer = fdSlicer.createFromFd(fd);
+      slicer.write(new Buffer("blah\n"), 0, 5, 0, function() {
+        if (err) return done(err);
+        fs.close(fd, done);
+      });
+    });
+  });
+});
+
+describe("BufferSlicer", function() {
+  it("invalid ref", function() {
+    var slicer = fdSlicer.createFromBuffer(new Buffer(16));
+    slicer.ref();
+    slicer.unref();
+    assert.throws(function() {
+      slicer.unref();
+    }, /invalid unref/);
+  });
+  it("read and write", function(done) {
+    var buf = new Buffer("through the tangled thread the needle finds its way");
+    var slicer = fdSlicer.createFromBuffer(buf);
+    var outBuf = new Buffer(1024);
+    slicer.read(outBuf, 10, 11, 8, function(err) {
+      if (err) return done(err);
+      assert.strictEqual(outBuf.toString('utf8', 10, 21), "the tangled");
+      slicer.write(new Buffer("derp"), 0, 4, 7, function(err) {
+        if (err) return done(err);
+        assert.strictEqual(buf.toString('utf8', 7, 19), "derp tangled");
+        done();
+      });
+    });
+  });
+  it("createReadStream", function(done) {
+    var str = "I never conquered rarely came, 16 just held such better days";
+    var buf = new Buffer(str);
+    var slicer = fdSlicer.createFromBuffer(buf);
+    var inStream = slicer.createReadStream();
+    var sink = new StreamSink();
+    inStream.pipe(sink);
+    sink.on('finish', function() {
+      assert.strictEqual(sink.toString(), str);
+      inStream.destroy();
+      done();
+    });
+  });
+  it("createWriteStream exceed buffer size", function(done) {
+    var slicer = fdSlicer.createFromBuffer(new Buffer(4));
+    var outStream = slicer.createWriteStream();
+    outStream.on('error', function(err) {
+      assert.strictEqual(err.code, 'ETOOBIG');
+      done();
+    });
+    outStream.write("hi!\n");
+    outStream.write("it warked\n");
+    outStream.end();
+  });
+  it("createWriteStream ok", function(done) {
+    var buf = new Buffer(1024);
+    var slicer = fdSlicer.createFromBuffer(buf);
+    var outStream = slicer.createWriteStream();
+    outStream.on('finish', function() {
+      assert.strictEqual(buf.toString('utf8', 0, "hi!\nit warked\n".length), "hi!\nit warked\n");
+      outStream.destroy();
+      done();
+    });
+    outStream.write("hi!\n");
+    outStream.write("it warked\n");
+    outStream.end();
+  });
+});

package/node_modules/@happier-dev/release-runtime/node_modules/yauzl/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "yauzl",
+  "version": "2.10.0",
+  "description": "yet another unzip library for node",
+  "main": "index.js",
+  "scripts": {
+    "test": "node test/test.js",
+    "test-cov": "istanbul cover test/test.js",
+    "test-travis": "istanbul cover --report lcovonly test/test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/thejoshwolfe/yauzl.git"
+  },
+  "keywords": [
+    "unzip",
+    "zip",
+    "stream",
+    "archive",
+    "file"
+  ],
+  "author": "Josh Wolfe <thejoshwolfe@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/thejoshwolfe/yauzl/issues"
+  },
+  "homepage": "https://github.com/thejoshwolfe/yauzl",
+  "dependencies": {
+    "fd-slicer": "~1.1.0",
+    "buffer-crc32": "~0.2.3"
+  },
+  "devDependencies": {
+    "bl": "~1.0.0",
+    "istanbul": "~0.3.4",
+    "pend": "~1.2.0"
+  },
+  "files": [
+    "index.js"
+  ]
+}

package/node_modules/@happier-dev/release-runtime/package.json

@@ -22,9 +22,9 @@
       "types": "./dist/assets.d.ts",
       "default": "./dist/assets.js"
     },
-    "./extractPlan": {
-      "types": "./dist/extractPlan.d.ts",
-      "default": "./dist/extractPlan.js"
+    "./archiveExtraction": {
+      "types": "./dist/archiveExtraction.d.ts",
+      "default": "./dist/archiveExtraction.js"
     },
     "./verifiedDownload": {
       "types": "./dist/verifiedDownload.d.ts",
@@ -39,5 +39,10 @@
       "require": "./releaseRings.cjs",
       "default": "./dist/releaseRings.js"
     }
+  },
+  "dependencies": {
+    "tar": "7.5.22",
+    "xz-decompress": "^0.2.3",
+    "yauzl": "^2.10.0"
   }
 }

package/node_modules/@happier-dev/release-runtime/releaseRings.cjs

@@ -0,0 +1,204 @@
+// This file exists so CommonJS consumers (notably Expo config evaluation on EAS)
+// can resolve release-ring metadata without requiring a built `dist/` folder.
+//
+// Keep this module dependency-free and deterministic.
+
+const RELEASE_RING_IDS = [
+  'stable',
+  'preview',
+  'publicdev',
+  'internalpreview',
+  'internaldev',
+];
+
+const PUBLIC_RELEASE_RING_IDS = ['stable', 'preview', 'publicdev'];
+
+/** @typedef {'public' | 'internal'} ReleaseRingVisibility */
+/** @typedef {'stable' | 'preview' | 'dev'} PublicReleaseRingLabel */
+
+/**
+ * @typedef {Object} ReleaseRingCatalogEntry
+ * @property {typeof RELEASE_RING_IDS[number]} id
+ * @property {ReleaseRingVisibility} visibility
+ * @property {PublicReleaseRingLabel} publicLabel
+ * @property {'main' | 'preview' | 'dev'} sourceBranch
+ * @property {'stable' | 'preview' | 'publicdev' | null} manifestChannel
+ * @property {'stable' | 'preview' | 'dev' | null} rollingReleaseSuffix
+ * @property {'production' | 'preview' | ''} embeddedPolicyEnv
+ * @property {'production' | 'preview' | 'development'} expoAppEnv
+ * @property {'production' | 'preview' | 'dev' | 'internalpreview' | 'internaldev'} expoUpdatesChannel
+ * @property {'happier' | 'happier-preview' | 'happier-dev' | 'happier-internalpreview' | 'happier-internaldev'} appScheme
+ * @property {boolean} supportsMobileStoreSubmit
+ */
+
+/** @type {Readonly<Record<typeof RELEASE_RING_IDS[number], ReleaseRingCatalogEntry>>} */
+const releaseRingCatalog = Object.freeze({
+  stable: {
+    id: 'stable',
+    visibility: 'public',
+    publicLabel: 'stable',
+    sourceBranch: 'main',
+    manifestChannel: 'stable',
+    rollingReleaseSuffix: 'stable',
+    embeddedPolicyEnv: 'production',
+    expoAppEnv: 'production',
+    expoUpdatesChannel: 'production',
+    appScheme: 'happier',
+    supportsMobileStoreSubmit: true,
+  },
+  preview: {
+    id: 'preview',
+    visibility: 'public',
+    publicLabel: 'preview',
+    sourceBranch: 'preview',
+    manifestChannel: 'preview',
+    rollingReleaseSuffix: 'preview',
+    embeddedPolicyEnv: 'preview',
+    expoAppEnv: 'preview',
+    expoUpdatesChannel: 'preview',
+    appScheme: 'happier-preview',
+    supportsMobileStoreSubmit: true,
+  },
+  publicdev: {
+    id: 'publicdev',
+    visibility: 'public',
+    publicLabel: 'dev',
+    sourceBranch: 'dev',
+    manifestChannel: 'publicdev',
+    rollingReleaseSuffix: 'dev',
+    embeddedPolicyEnv: 'preview',
+    expoAppEnv: 'preview',
+    expoUpdatesChannel: 'dev',
+    appScheme: 'happier-dev',
+    supportsMobileStoreSubmit: true,
+  },
+  internalpreview: {
+    id: 'internalpreview',
+    visibility: 'internal',
+    publicLabel: 'preview',
+    sourceBranch: 'dev',
+    manifestChannel: null,
+    rollingReleaseSuffix: null,
+    embeddedPolicyEnv: 'preview',
+    expoAppEnv: 'preview',
+    expoUpdatesChannel: 'internalpreview',
+    appScheme: 'happier-internalpreview',
+    supportsMobileStoreSubmit: false,
+  },
+  internaldev: {
+    id: 'internaldev',
+    visibility: 'internal',
+    publicLabel: 'dev',
+    sourceBranch: 'dev',
+    manifestChannel: null,
+    rollingReleaseSuffix: null,
+    embeddedPolicyEnv: '',
+    expoAppEnv: 'development',
+    expoUpdatesChannel: 'internaldev',
+    appScheme: 'happier-internaldev',
+    supportsMobileStoreSubmit: false,
+  },
+});
+
+/**
+ * @param {typeof RELEASE_RING_IDS[number]} id
+ * @returns {ReleaseRingCatalogEntry}
+ */
+function getReleaseRingCatalogEntry(id) {
+  const entry = releaseRingCatalog[id];
+  if (!entry) {
+    throw new Error(`Unknown release ring: ${String(id)}`);
+  }
+  return entry;
+}
+
+/**
+ * @returns {readonly ReleaseRingCatalogEntry[]}
+ */
+function listReleaseRingCatalogEntries() {
+  return RELEASE_RING_IDS.map((id) => releaseRingCatalog[id]);
+}
+
+/**
+ * @param {typeof RELEASE_RING_IDS[number]} id
+ */
+function isPublicReleaseRingId(id) {
+  return getReleaseRingCatalogEntry(id).visibility === 'public';
+}
+
+/**
+ * @param {typeof RELEASE_RING_IDS[number]} id
+ * @returns {PublicReleaseRingLabel}
+ */
+function getReleaseRingPublicLabel(id) {
+  return getReleaseRingCatalogEntry(id).publicLabel;
+}
+
+/** @type {Readonly<Record<string, typeof RELEASE_RING_IDS[number]>>} */
+const releaseRingAliases = Object.freeze({
+  stable: 'stable',
+  production: 'stable',
+  prod: 'stable',
+  preview: 'preview',
+  publicdev: 'publicdev',
+  'public-dev': 'publicdev',
+  public_dev: 'publicdev',
+  dev: 'publicdev',
+  internalpreview: 'internalpreview',
+  'internal-preview': 'internalpreview',
+  internal_preview: 'internalpreview',
+  canary: 'internalpreview',
+  internaldev: 'internaldev',
+  'internal-dev': 'internaldev',
+  internal_dev: 'internaldev',
+  development: 'internaldev',
+});
+
+/**
+ * @param {unknown} raw
+ * @returns {typeof RELEASE_RING_IDS[number] | ''}
+ */
+function normalizeReleaseRingId(raw) {
+  const value = String(raw ?? '').trim().toLowerCase();
+  if (!value) return '';
+  return releaseRingAliases[value] ?? '';
+}
+
+/**
+ * @returns {readonly ReleaseRingCatalogEntry[]}
+ */
+function listPublicReleaseRingCatalogEntries() {
+  return listReleaseRingCatalogEntries().filter((entry) => entry.visibility === 'public');
+}
+
+/**
+ * @returns {readonly PublicReleaseRingLabel[]}
+ */
+function listPublicReleaseRingLabels() {
+  return PUBLIC_RELEASE_RING_IDS.map((id) => releaseRingCatalog[id].publicLabel);
+}
+
+/**
+ * @param {unknown} raw
+ * @returns {typeof PUBLIC_RELEASE_RING_IDS[number] | ''}
+ */
+function normalizePublicReleaseRingId(raw) {
+  const ringId = normalizeReleaseRingId(raw);
+  if (!ringId || !isPublicReleaseRingId(ringId)) {
+    return '';
+  }
+  return ringId;
+}
+
+module.exports = {
+  RELEASE_RING_IDS,
+  PUBLIC_RELEASE_RING_IDS,
+  getReleaseRingCatalogEntry,
+  listReleaseRingCatalogEntries,
+  isPublicReleaseRingId,
+  getReleaseRingPublicLabel,
+  normalizeReleaseRingId,
+  listPublicReleaseRingCatalogEntries,
+  listPublicReleaseRingLabels,
+  normalizePublicReleaseRingId,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happier-dev/relay-server",
-  "version": "0.2.6-dev.1778098335.1",
+  "version": "0.2.11-preview.3",
   "description": "Happier server runner (downloads and verifies the correct server binary for your platform).",
   "repository": "https://github.com/happier-dev/happier.git",
   "author": "Leeroy Brun <leeroy.brun@gmail.com>",

package/src/archiveCache.mjs

@@ -0,0 +1,25 @@
+import { mkdir, rm } from 'node:fs/promises';
+
+import { extractFirstPartyReleaseArchiveToDirectory } from '@happier-dev/release-runtime/archiveExtraction';
+
+export async function extractReleaseArchiveIntoCache({ archiveName, archivePath, cacheDir }) {
+  await rm(cacheDir, { recursive: true, force: true });
+  await mkdir(cacheDir, { recursive: true });
+  try {
+    await extractFirstPartyReleaseArchiveToDirectory({
+      archiveName,
+      archivePath,
+      extractDir: cacheDir,
+    });
+  } catch (error) {
+    try {
+      await rm(cacheDir, { recursive: true, force: true });
+    } catch (cleanupError) {
+      throw new AggregateError(
+        [error, cleanupError],
+        `[relay-server] archive extraction failed and partial cache cleanup also failed: ${cacheDir}`,
+      );
+    }
+    throw error;
+  }
+}