[pull] master from handlebars-lang:master

.github/workflows/ci.yml

@@ -52,6 +52,10 @@ jobs:
       - name: Test
         run: npm run test
 
+      - name: Test (Publish)
+        if: matrix.node-version != '20'
+        run: npx vitest run --project publish
+
       - name: Test (Integration)
         if: matrix.operating-system == 'ubuntu-latest'
         run: npm run test:integration

package.json

@@ -48,6 +48,7 @@
     "test:browser": "vitest run --project browser",
     "test:unit": "vitest run --project node",
     "test:tasks": "vitest run --project tasks",
+    "test:publish": "npm run build && vitest run --project publish",
     "test:browser-smoke": "playwright test --config tests/browser/playwright.config.js",
     "test:serve": "npx serve -l 9999 .",
     "test:integration": "npm run build && ./tests/integration/run-integration-tests.sh",

tasks/publish-to-aws.js

@@ -4,6 +4,13 @@ const { S3, PutObjectCommand } = require('@aws-sdk/client-s3');
 const git = require('./util/git');
 const semver = require('semver');
 
+const PUBLISHED_FILES = [
+  'handlebars.js',
+  'handlebars.min.js',
+  'handlebars.runtime.js',
+  'handlebars.runtime.min.js',
+];
+
 let s3Client;
 
 async function main() {
@@ -13,24 +20,28 @@ async function main() {
   const commitInfo = await git.commitInfo();
   console.log('tag: ', commitInfo.tagName);
 
+  const suffixes = buildSuffixes(commitInfo);
+
+  if (suffixes.length > 0) {
+    validateS3Env();
+    console.log('publishing file-suffixes: ' + JSON.stringify(suffixes));
+    await publish(suffixes);
+  }
+}
+
+function buildSuffixes(commitInfo) {
   const suffixes = [];
 
-  // Publish the master as "latest" and with the commit-id
   if (commitInfo.isMaster) {
     suffixes.push('-latest');
     suffixes.push('-' + commitInfo.headSha);
   }
 
-  // Publish tags by their tag-name
   if (commitInfo.tagName != null && semver.valid(commitInfo.tagName)) {
     suffixes.push('-' + commitInfo.tagName);
   }
 
-  if (suffixes.length > 0) {
-    validateS3Env();
-    console.log('publishing file-suffixes: ' + JSON.stringify(suffixes));
-    await publish(suffixes);
-  }
+  return suffixes;
 }
 
 function validateS3Env() {
@@ -44,33 +55,30 @@ function validateS3Env() {
   }
 }
 
-async function publish(suffixes) {
-  const publishPromises = suffixes.map((suffix) => publishSuffix(suffix));
+async function publish(suffixes, overrides) {
+  const publishPromises = suffixes.map((suffix) =>
+    publishSuffix(suffix, overrides)
+  );
   return Promise.all(publishPromises);
 }
 
-async function publishSuffix(suffix) {
-  const filenames = [
-    'handlebars.js',
-    'handlebars.min.js',
-    'handlebars.runtime.js',
-    'handlebars.runtime.min.js',
-  ];
-  const publishPromises = filenames.map(async (filename) => {
+async function publishSuffix(suffix, overrides) {
+  const publishPromises = PUBLISHED_FILES.map(async (filename) => {
     const nameInBucket = getNameInBucket(filename, suffix);
     const localFile = getLocalFile(filename);
-    await uploadToBucket(localFile, nameInBucket);
+    await uploadToBucket(localFile, nameInBucket, overrides);
     console.log(`Published ${localFile} to build server (${nameInBucket})`);
   });
   return Promise.all(publishPromises);
 }
 
-async function uploadToBucket(localFile, nameInBucket) {
-  const s3 = getS3Client();
+async function uploadToBucket(localFile, nameInBucket, overrides) {
+  const s3 = overrides?.s3Client ?? getS3Client();
+  const bucket = overrides?.bucket ?? process.env.S3_BUCKET_NAME;
 
   return s3.send(
     new PutObjectCommand({
-      Bucket: process.env.S3_BUCKET_NAME,
+      Bucket: bucket,
       Key: nameInBucket,
       Body: fs.readFileSync(localFile, 'utf8'),
     })
@@ -98,6 +106,15 @@ function getLocalFile(filename) {
   return 'dist/' + filename;
 }
 
+module.exports = {
+  PUBLISHED_FILES,
+  buildSuffixes,
+  validateS3Env,
+  publish,
+  getNameInBucket,
+  getLocalFile,
+};
+
 if (require.main === module) {
   main().catch((err) => {
     console.error(err);

tasks/tests/fake-s3.js

@@ -0,0 +1,81 @@
+const http = require('http');
+
+/**
+ * Minimal in-memory S3-compatible server for testing.
+ * Supports PutObject and GetObject via path-style requests.
+ */
+function createFakeS3() {
+  const buckets = new Map();
+
+  const server = http.createServer((req, res) => {
+    const { bucket, key } = parsePath(req.url);
+
+    if (!bucket || !buckets.has(bucket)) {
+      res.writeHead(404, { 'Content-Type': 'application/xml' });
+      res.end('<Error><Code>NoSuchBucket</Code></Error>');
+      return;
+    }
+
+    const store = buckets.get(bucket);
+
+    if (req.method === 'PUT' && key) {
+      const chunks = [];
+      req.on('data', (chunk) => chunks.push(chunk));
+      req.on('end', () => {
+        store.set(key, Buffer.concat(chunks));
+        res.writeHead(200);
+        res.end();
+      });
+    } else if ((req.method === 'GET' || req.method === 'HEAD') && key) {
+      if (!store.has(key)) {
+        res.writeHead(404, { 'Content-Type': 'application/xml' });
+        res.end('<Error><Code>NoSuchKey</Code></Error>');
+        return;
+      }
+      const body = store.get(key);
+      res.writeHead(200, {
+        'Content-Length': body.length,
+        'Content-Type': 'application/octet-stream',
+      });
+      res.end(req.method === 'HEAD' ? undefined : body);
+    } else {
+      res.writeHead(405);
+      res.end();
+    }
+  });
+
+  return {
+    start() {
+      return new Promise((resolve) => {
+        server.listen(0, '127.0.0.1', () => {
+          const { port } = server.address();
+          resolve({
+            address: `http://127.0.0.1:${port}`,
+            createBucket(name) {
+              if (!buckets.has(name)) buckets.set(name, new Map());
+            },
+            reset() {
+              for (const store of buckets.values()) store.clear();
+            },
+            stop() {
+              return new Promise((r) => server.close(r));
+            },
+          });
+        });
+      });
+    },
+  };
+}
+
+function parsePath(url) {
+  // Path-style: /<bucket>/<key>
+  const parts = new URL(url, 'http://localhost').pathname
+    .replace(/^\//, '')
+    .split('/');
+  return {
+    bucket: parts[0] || null,
+    key: parts.slice(1).join('/') || null,
+  };
+}
+
+module.exports = { createFakeS3 };