Publish

- @now/node-server@0.4.27-canary.0
 - @now/node@0.4.29-canary.0

lerna.json

@@ -2,24 +2,7 @@
   "npmClient": "yarn",
   "useWorkspaces": true,
   "packages": [
-    "packages/now-build-utils",
-    "packages/now-node-bridge",
-    "packages/now-php-bridge",
-    "packages/now-bash",
-    "packages/now-cgi",
-    "packages/now-go",
-    "packages/now-html-minifier",
-    "packages/now-lambda",
-    "packages/now-md",
-    "packages/now-mdx-deck",
-    "packages/now-next",
-    "packages/now-node",
-    "packages/now-node-server",
-    "packages/now-optipng",
-    "packages/now-php",
-    "packages/now-python",
-    "packages/now-static-build",
-    "packages/now-wordpress"
+    "packages/*"
   ],
   "command": {
     "publish": {

packages/now-build-utils/file-ref.js

@@ -49,7 +49,7 @@ class FileRef {
     assert(url);
 
     await semaToDownloadFromS3.acquire();
-    console.time(`downloading ${url}`);
+    // console.time(`downloading ${url}`);
     try {
       return await retry(
         async () => {
@@ -66,7 +66,7 @@ class FileRef {
         { factor: 1, retries: 3 },
       );
     } finally {
-      console.timeEnd(`downloading ${url}`);
+      // console.timeEnd(`downloading ${url}`);
       semaToDownloadFromS3.release();
     }
   }

packages/now-build-utils/fs/bootstrap-yarn.js

@@ -1,3 +1,5 @@
+/* eslint-disable arrow-body-style,no-multi-assign,no-param-reassign */
+
 const MemoryFileSystem = require('memory-fs');
 const fs = require('fs');
 const path = require('path');
@@ -19,76 +21,222 @@ function isInsideCachePath(filename) {
   return !relative.startsWith('..');
 }
 
-const saveCreateWriteStream = fs.createWriteStream;
-fs.createWriteStream = (...args) => {
-  const filename = args[0];
-  if (!isInsideCachePath(filename)) {
-    return saveCreateWriteStream.call(fs, ...args);
-  }
+function replaceFn(name, newFnFactory) {
+  const prevFn = fs[name];
+  fs[name] = newFnFactory(prevFn);
+}
 
-  vfs.mkdirpSync(path.dirname(filename));
-  fs.writeFileSync(filename, Buffer.alloc(0));
-  const stream = vfs.createWriteStream(...args);
-
-  stream.on('finish', () => {
-    setTimeout(() => {
-      stream.emit('close');
-    });
-  });
-
-  return stream;
-};
-
-const saveReadFile = fs.readFile;
-fs.readFile = (...args) => {
-  const filename = args[0];
-  if (!isInsideCachePath(filename)) {
-    return saveReadFile.call(fs, ...args);
-  }
-
-  const callback = args[args.length - 1];
-  return vfs.readFile(...args.slice(0, -1), (error, result) => {
-    if (error) {
-      saveReadFile.call(fs, ...args);
-      return;
+replaceFn('createWriteStream', (prevFn) => {
+  return (...args) => {
+    const filename = args[0];
+    if (!isInsideCachePath(filename)) {
+      return prevFn.call(fs, ...args);
     }
 
-    callback(error, result);
-  });
-};
+    const stream = vfs.createWriteStream(...args);
 
-const saveCopyFile = fs.copyFile;
-fs.copyFile = (...args) => {
-  const src = args[0];
-  const dest = args[1];
-  const callback = args[args.length - 1];
+    stream.on('finish', () => {
+      setTimeout(() => {
+        stream.emit('close');
+      });
+    });
 
-  if (isInsideCachePath(src) && !isInsideCachePath(dest)) {
-    const buffer = vfs.readFileSync(src);
-    return fs.writeFile(dest, buffer, callback);
-  }
+    setTimeout(() => {
+      stream.emit('open');
+    });
 
-  if (!isInsideCachePath(src) && isInsideCachePath(dest)) {
-    const buffer = fs.readFileSync(src);
+    return stream;
+  };
+});
 
-    vfs.mkdirpSync(path.dirname(dest));
-    fs.writeFileSync(dest, Buffer.alloc(0));
-    return vfs.writeFile(dest, buffer, callback);
-  }
+replaceFn('readFile', (prevFn) => {
+  return (...args) => {
+    const filename = args[0];
+    if (!isInsideCachePath(filename)) {
+      return prevFn.call(fs, ...args);
+    }
 
-  return saveCopyFile.call(fs, ...args);
-};
+    const callback = args[args.length - 1];
+    return vfs.readFile(...args.slice(0, -1), (error, result) => {
+      if (error) {
+        return prevFn.call(fs, ...args);
+      }
 
-const saveWriteFile = fs.writeFile;
-fs.writeFile = (...args) => {
-  const filename = args[0];
-  if (!isInsideCachePath(filename)) {
-    return saveWriteFile.call(fs, ...args);
-  }
+      return callback(error, result);
+    });
+  };
+});
 
-  vfs.mkdirpSync(path.dirname(filename));
-  fs.writeFileSync(filename, Buffer.alloc(0));
-  return vfs.writeFile(...args);
-};
+replaceFn('readdir', (prevFn) => {
+  return (...args) => {
+    const dirname = args[0];
+    if (!isInsideCachePath(dirname)) {
+      return prevFn.call(fs, ...args);
+    }
+
+    const callback = args[args.length - 1];
+    return prevFn.call(fs, dirname, (error, results) => {
+      if (error) {
+        results = [];
+      }
+
+      return vfs.readdir(dirname, (error2, results2) => {
+        if (error2) {
+          return callback(error2);
+        }
+
+        // eslint-disable-next-line no-restricted-syntax
+        for (const result2 of results2) {
+          if (!results.includes(result2)) {
+            results.push(result2);
+          }
+        }
+
+        return callback(error2, results);
+      });
+    });
+  };
+});
+
+replaceFn('stat', (prevFn) => {
+  return (...args) => {
+    const filename = args[0];
+    if (!isInsideCachePath(filename)) {
+      return prevFn.call(fs, ...args);
+    }
+
+    const callback = args[args.length - 1];
+    return vfs.stat(...args.slice(0, -1), (error, result) => {
+      if (error) {
+        return prevFn.call(fs, ...args);
+      }
+
+      result.atime = result.mtime = new Date();
+      return callback(error, result);
+    });
+  };
+});
+
+replaceFn('lstat', (prevFn) => {
+  return (...args) => {
+    const filename = args[0];
+    if (!isInsideCachePath(filename)) {
+      return prevFn.call(fs, ...args);
+    }
+
+    const callback = args[args.length - 1];
+    return vfs.stat(...args.slice(0, -1), (error, result) => {
+      if (error) {
+        return prevFn.call(fs, ...args);
+      }
+
+      result.atime = result.mtime = new Date();
+      return callback(error, result);
+    });
+  };
+});
+
+replaceFn('exists', (prevFn) => {
+  return (...args) => {
+    const filename = args[0];
+    if (!isInsideCachePath(filename)) {
+      return prevFn.call(fs, ...args);
+    }
+
+    const callback = args[args.length - 1];
+    return vfs.exists(...args.slice(0, -1), (result) => {
+      if (!result) {
+        return prevFn.call(fs, ...args);
+      }
+
+      return callback(result);
+    });
+  };
+});
+
+replaceFn('copyFile', (prevFn) => {
+  return (...args) => {
+    const src = args[0];
+    const dest = args[1];
+    const callback = args[args.length - 1];
+
+    if (isInsideCachePath(src) && !isInsideCachePath(dest)) {
+      const buffer = vfs.readFileSync(src);
+      return fs.writeFile(dest, buffer, callback);
+    }
+
+    if (!isInsideCachePath(src) && isInsideCachePath(dest)) {
+      const buffer = fs.readFileSync(src);
+      return vfs.writeFile(dest, buffer, callback);
+    }
+
+    return prevFn.call(fs, ...args);
+  };
+});
+
+replaceFn('writeFile', (prevFn) => {
+  return (...args) => {
+    const filename = args[0];
+    if (!isInsideCachePath(filename)) {
+      return prevFn.call(fs, ...args);
+    }
+
+    return vfs.writeFile(...args);
+  };
+});
+
+replaceFn('mkdir', (prevFn) => {
+  return (...args) => {
+    const dirname = args[0];
+    if (!isInsideCachePath(dirname)) {
+      return prevFn.call(fs, ...args);
+    }
+
+    const callback = args[args.length - 1];
+    return prevFn.call(fs, dirname, (error) => {
+      if (error) {
+        return callback(error);
+      }
+
+      return vfs.mkdirp(dirname, callback);
+    });
+  };
+});
+
+replaceFn('utimes', (prevFn) => {
+  return (...args) => {
+    const filename = args[0];
+    if (!isInsideCachePath(filename)) {
+      return prevFn.call(fs, ...args);
+    }
+
+    const callback = args[args.length - 1];
+    return setTimeout(callback, 0);
+  };
+});
+
+replaceFn('chmod', (prevFn) => {
+  return (...args) => {
+    const filename = args[0];
+    if (!isInsideCachePath(filename)) {
+      return prevFn.call(fs, ...args);
+    }
+
+    const callback = args[args.length - 1];
+    return setTimeout(callback, 0);
+  };
+});
+
+replaceFn('chown', (prevFn) => {
+  return (...args) => {
+    const filename = args[0];
+    if (!isInsideCachePath(filename)) {
+      return prevFn.call(fs, ...args);
+    }
+
+    const callback = args[args.length - 1];
+    return setTimeout(callback, 0);
+  };
+});
 
 require(yarnPath);

packages/now-build-utils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/build-utils",
-  "version": "0.4.32",
+  "version": "0.4.33-canary.1",
   "license": "MIT",
   "dependencies": {
     "async-retry": "1.2.3",

packages/now-node-server/index.js

@@ -47,7 +47,7 @@ async function downloadInstallAndBundle(
       'package.json': new FileBlob({
         data: JSON.stringify({
           dependencies: {
-            '@zeit/ncc': '0.11.0',
+            '@zeit/ncc': '0.12.1',
           },
         }),
       }),

packages/now-node-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/node-server",
-  "version": "0.4.26",
+  "version": "0.4.27-canary.0",
   "license": "MIT",
   "dependencies": {
     "@now/node-bridge": "^0.1.10",

packages/now-node/index.js

@@ -45,7 +45,7 @@ async function downloadInstallAndBundle(
       'package.json': new FileBlob({
         data: JSON.stringify({
           dependencies: {
-            '@zeit/ncc': '0.11.0',
+            '@zeit/ncc': '0.12.1',
           },
         }),
       }),

packages/now-node/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/node",
-  "version": "0.4.28",
+  "version": "0.4.29-canary.0",
   "license": "MIT",
   "dependencies": {
     "@now/node-bridge": "^0.1.10",

test/lib/deployment/test-deployment.js

@@ -22,7 +22,7 @@ async function packAndDeploy (builderPath) {
 
 const RANDOMNESS_PLACEHOLDER_STRING = 'RANDOMNESS_PLACEHOLDER';
 
-async function testDeployment ({ builderUrl, buildUtilsUrl }, fixturePath) {
+async function testDeployment ({ builderUrl, buildUtilsUrl }, fixturePath, buildDelegate) {
   console.log('testDeployment', fixturePath);
   const globResult = await glob(`${fixturePath}/**`, { nodir: true });
   const bodies = globResult.reduce((b, f) => {
@@ -63,6 +63,10 @@ async function testDeployment ({ builderUrl, buildUtilsUrl }, fixturePath) {
         config.useBuildUtils = `https://${buildUtilsUrl}`;
       }
     }
+
+    if (buildDelegate) {
+      buildDelegate(build);
+    }
   }
 
   bodies['now.json'] = Buffer.from(JSON.stringify(nowJson));
@@ -84,7 +88,8 @@ async function testDeployment ({ builderUrl, buildUtilsUrl }, fixturePath) {
       if (!text.includes(probe.mustContain)) {
         await fs.writeFile(path.join(__dirname, 'failed-page.txt'), text);
         throw new Error(
-          `Fetched page ${probeUrl} does not contain ${probe.mustContain}`
+          `Fetched page ${probeUrl} does not contain ${probe.mustContain}.`
+          + ` Instead it contains ${text.slice(0, 60)}`
         );
       }
     } else {
@@ -113,7 +118,8 @@ async function fetchDeploymentUrl (url, opts) {
   for (let i = 0; i < 500; i += 1) {
     const resp = await fetch(url, opts);
     const text = await resp.text();
-    if (text && !text.includes('Join Free')) {
+    if (text && !text.includes('Join Free')
+        && !text.includes('The page could not be found')) {
       return text;
     }