@naturalcycles/backend-lib 9.78.0 → 9.80.0

package/dist/deploy/deployHealthCheck.d.ts

@@ -4,11 +4,6 @@ export interface DeployHealthCheckOptions {
     maxTries?: number;
     timeoutSec?: number;
     intervalSec?: number;
-    logOnFailure?: boolean;
-    logOnSuccess?: boolean;
-    gaeProject?: string;
-    gaeService?: string;
-    gaeVersion?: string;
     authHeader?: string;
 }
 export declare const deployHealthCheckCliOptions: CliOptions;
@@ -16,5 +11,6 @@ export declare const deployHealthCheckCliOptions: CliOptions;
  * Requires up to `healthyThreshold` consecutive OK responses to succeed.
  * Fails on up to `unhealthyThreshold` consecutive FAIL responses.
  * Fails after maxTries.
+ * Throws on failure.
  */
 export declare function deployHealthCheck(url: string, opt?: DeployHealthCheckOptions): Promise<void>;

package/dist/deploy/deployHealthCheck.js

@@ -4,7 +4,6 @@ import { getFetcher } from '@naturalcycles/js-lib/http';
 import { _filterFalsyValues, _filterUndefinedValues, } from '@naturalcycles/js-lib/object/object.util.js';
 import { pDelay } from '@naturalcycles/js-lib/promise/pDelay.js';
 import { dimGrey, red } from '@naturalcycles/nodejs-lib/colors';
-import { exec2 } from '@naturalcycles/nodejs-lib/exec2';
 import { coloredHttpCode } from '../server/request.log.util.js';
 export const deployHealthCheckCliOptions = {
     thresholdHealthy: {
@@ -27,25 +26,6 @@ export const deployHealthCheckCliOptions = {
         type: 'number',
         default: 1,
     },
-    logOnFailure: {
-        type: 'boolean',
-        default: true,
-        desc: 'Show server logs on health check failure (requires gaeProject, gaeService, gaeVersion)',
-    },
-    logOnSuccess: {
-        type: 'boolean',
-        default: false,
-        desc: 'Show server logs on health check success (requires gaeProject, gaeService, gaeVersion)',
-    },
-    gaeProject: {
-        type: 'string',
-    },
-    gaeService: {
-        type: 'string',
-    },
-    gaeVersion: {
-        type: 'string',
-    },
     authHeader: {
         type: 'string',
     },
@@ -58,9 +38,10 @@ const inspectOpt = {
  * Requires up to `healthyThreshold` consecutive OK responses to succeed.
  * Fails on up to `unhealthyThreshold` consecutive FAIL responses.
  * Fails after maxTries.
+ * Throws on failure.
  */
 export async function deployHealthCheck(url, opt = {}) {
-    const { thresholdHealthy = 5, thresholdUnhealthy = 8, maxTries = 30, timeoutSec = 30, intervalSec = 1, logOnFailure, logOnSuccess, gaeProject, gaeService, gaeVersion, authHeader, } = opt;
+    const { thresholdHealthy = 5, thresholdUnhealthy = 8, maxTries = 30, timeoutSec = 30, intervalSec = 1, authHeader, } = opt;
     let attempt = 0;
     let countHealthy = 0;
     let countUnhealthy = 0;
@@ -74,19 +55,7 @@ export async function deployHealthCheck(url, opt = {}) {
     }
     if (failed) {
         console.log(red(`Health check failed!`));
-        if (logOnFailure) {
-            try {
-                exec2.spawn(`gcloud app logs read --project ${gaeProject} --service ${gaeService} --version ${gaeVersion}`);
-            }
-            catch { }
-        }
-        process.exit(1);
-    }
-    if (logOnSuccess) {
-        try {
-            exec2.spawn(`gcloud app logs read --project ${gaeProject} --service ${gaeService} --version ${gaeVersion}`);
-        }
-        catch { }
+        throw new Error(`Health check failed: ${doneReason}`);
     }
     async function makeAttempt() {
         attempt++;

package/dist/deploy/index.d.ts

@@ -1,11 +1,4 @@
-import type { BackendCfg } from './backend.cfg.util.js';
-import { getBackendCfg } from './backend.cfg.util.js';
-import type { DeployInfo } from './deploy.model.js';
-import { createAppYaml, createDeployInfo } from './deploy.util.js';
-import { deployGae } from './deployGae.js';
 import type { DeployHealthCheckOptions } from './deployHealthCheck.js';
 import { deployHealthCheck } from './deployHealthCheck.js';
-import { deployPrepare } from './deployPrepare.js';
-export type { BackendCfg, DeployHealthCheckOptions, DeployInfo };
-export { createAppYaml, createDeployInfo, deployGae, deployHealthCheck, deployPrepare, getBackendCfg, };
-export * from './deployInfo.util.js';
+export type { DeployHealthCheckOptions };
+export { deployHealthCheck };

package/dist/deploy/index.js

@@ -1,7 +1,2 @@
-import { getBackendCfg } from './backend.cfg.util.js';
-import { createAppYaml, createDeployInfo } from './deploy.util.js';
-import { deployGae } from './deployGae.js';
 import { deployHealthCheck } from './deployHealthCheck.js';
-import { deployPrepare } from './deployPrepare.js';
-export { createAppYaml, createDeployInfo, deployGae, deployHealthCheck, deployPrepare, getBackendCfg, };
-export * from './deployInfo.util.js';
+export { deployHealthCheck };

package/dist/express/createDefaultApp.js

@@ -5,9 +5,9 @@ import { logMiddleware } from '../server/logMiddleware.js';
 import { notFoundMiddleware } from '../server/notFoundMiddleware.js';
 import { requestTimeoutMiddleware } from '../server/requestTimeoutMiddleware.js';
 import { simpleRequestLoggerMiddleware } from '../server/simpleRequestLoggerMiddleware.js';
-import { isGAE } from '../util.js';
 const isTest = process.env['APP_ENV'] === 'test';
 const isDev = process.env['APP_ENV'] === 'dev';
+const isGAE = !!process.env['GAE_INSTANCE'];
 export async function createDefaultApp(cfg) {
     const { sentryService } = cfg;
     const { default: express } = await import('express');
@@ -43,7 +43,7 @@ export async function createDefaultApp(cfg) {
         maxAge: 86400,
         ...cfg.corsOptions,
     }));
-    if (!isGAE() && isTest) {
+    if (!isGAE && isTest) {
         // compression is not used in AppEngine, because AppEngine provides it by default
         app.use(compressionMiddleware());
     }

package/dist/server/compressionMiddleware.d.ts

@@ -10,6 +10,18 @@ export interface CompressionOptions {
      * @default 1024
      */
     threshold?: number | string;
+    /**
+     * Bodies sent in one `res.end(chunk)` call (which is what `res.json` and `res.send` do) up to this
+     * size are compressed synchronously on the event loop, instead of through a zlib stream.
+     * For typical JSON responses the per-response stream setup and threadpool round-trip cost more
+     * than the compression itself, and the sync path also keeps an exact `Content-Length`
+     * (streamed responses are chunked).
+     * Bodies above this size, and bodies written in several `res.write` calls, are streamed.
+     * Set to `0` to always stream.
+     *
+     * @default 128kb
+     */
+    syncMaxBytes?: number | string;
     /**
      * Encoding to use when Accept-Encoding header is not present.
      * @default 'identity'
@@ -39,7 +51,8 @@ export interface CompressionOptions {
 /**
  * Compression middleware with support for gzip, deflate, brotli, and zstd.
  *
- * This is a fork of the `compression` npm package with added zstd support.
+ * This is a fork of the `compression` npm package with added zstd support,
+ * and a synchronous fast path for single-chunk bodies (see `syncMaxBytes`).
  *
  * Encoding preference order: zstd > br > gzip > deflate
  */

package/dist/server/compressionMiddleware.js

@@ -22,7 +22,8 @@ const cacheControlNoTransformRegExp = /(?:^|,)\s*?no-transform\s*?(?:,|$)/i;
 /**
  * Compression middleware with support for gzip, deflate, brotli, and zstd.
  *
- * This is a fork of the `compression` npm package with added zstd support.
+ * This is a fork of the `compression` npm package with added zstd support,
+ * and a synchronous fast path for single-chunk bodies (see `syncMaxBytes`).
  *
  * Encoding preference order: zstd > br > gzip > deflate
  */
@@ -37,10 +38,14 @@ export function compressionMiddleware(options) {
         },
     };
     // Zstd options
+    // Level 1 instead of zstd's own default of 3: for typical JSON responses the CPU cost and
+    // compression ratio are the same (measured 2026-10 on 22 KB and 115 KB payloads), but a level 3
+    // stream holds ~850 KB of native memory per in-flight response vs ~150 KB at level 1.
+    // That per-response allocation churn is what MALLOC_ARENA_MAX=2 works around on Cloud Run.
     const optsZstd = {
         ...opts.zstd,
         params: {
-            [zlib.constants.ZSTD_c_compressionLevel]: 3,
+            [zlib.constants.ZSTD_c_compressionLevel]: 1,
             ...opts.zstd?.params,
         },
     };
@@ -56,11 +61,17 @@ export function compressionMiddleware(options) {
         zlibOpts.windowBits = opts.windowBits;
     if (opts.chunkSize !== undefined)
         zlibOpts.chunkSize = opts.chunkSize;
+    const codecOpts = { zstd: optsZstd, brotli: optsBrotli, zlib: zlibOpts };
     const filter = opts.filter || shouldCompress;
     const threshold = parseBytes(opts.threshold) ?? 1024;
+    const syncMaxBytes = parseBytes(opts.syncMaxBytes) ?? 128 * 1024;
     const enforceEncoding = opts.enforceEncoding || 'identity';
     return function compression(req, res, next) {
         let ended = false;
+        // Set by the first `res.write`: the body comes in several chunks, so only the stream path applies
+        let wrote = false;
+        // Set once the compress-or-not decision has been made for this response (by either path)
+        let decided = false;
         let length;
         let listeners = [];
         let stream;
@@ -78,6 +89,7 @@ export function compressionMiddleware(options) {
             if (ended) {
                 return false;
             }
+            wrote = true;
             if (!headersSent(res)) {
                 res.writeHead(res.statusCode);
             }
@@ -96,6 +108,26 @@ export function compressionMiddleware(options) {
                 if (!res.getHeader('Content-Length')) {
                     length = chunkLength(chunk, encodingOrCallback);
                 }
+                // Single-chunk body (no prior `res.write`): the whole body is right here, so compress it
+                // synchronously instead of setting up a zlib stream for one chunk.
+                if (chunk && !wrote && !decided) {
+                    const encoding = typeof encodingOrCallback === 'function' ? undefined : encodingOrCallback;
+                    const body = toBuffer(chunk, encoding);
+                    if (body.length <= syncMaxBytes) {
+                        const method = decide(body.length);
+                        if (method) {
+                            const compressed = compressSync(method, body, codecOpts);
+                            res.setHeader('Content-Encoding', method);
+                            res.setHeader('Content-Length', compressed.length);
+                            ended = true;
+                            const cb = typeof encodingOrCallback === 'function' ? encodingOrCallback : callback;
+                            // encoding is irrelevant for a Buffer chunk; it is passed to satisfy the `end` overload
+                            return _end.call(res, compressed, 'utf8', cb);
+                        }
+                        // Not compressing: falls through to the plain `end`.
+                        // The `onHeaders` listener below sees `decided` and does nothing.
+                    }
+                }
                 res.writeHead(res.statusCode);
             }
             if (!stream) {
@@ -127,46 +159,36 @@ export function compressionMiddleware(options) {
             addListeners(res, _on, listeners);
             listeners = null;
         }
-        // Release the compression stream when the response closes, freeing native
-        // zlib memory even if the client disconnected before the response finished.
-        // Registered before onHeaders so a close that happens before the stream
-        // exists is not missed (the `closed` flag below handles a stream created
-        // afterwards). Fixes CVE-2026-87776 / GHSA-vc2v-76pw-4v95.
-        // We use `stream.destroy()` (not the `destroy` npm package upstream added)
-        // because our Node target frees the zlib handle on destroy().
-        _on.call(res, 'close', function onResponseClose() {
-            closed = true;
-            stream?.destroy();
-        });
-        onHeaders(res, function onResponseHeaders() {
+        /**
+         * The compress-or-not decision, shared by the sync path (`res.end` holding the whole body)
+         * and the stream path (`onHeaders`).
+         * Returns the encoding to use, or undefined when the response is to be sent as-is.
+         */
+        function decide(bodyLength) {
+            decided = true;
             // determine if request is filtered
             if (!filter(req, res)) {
-                nocompress('filtered');
-                return;
+                return nocompress('filtered');
             }
             // determine if the entity should be transformed
             if (!shouldTransform(req, res)) {
-                nocompress('no transform');
-                return;
+                return nocompress('no transform');
             }
             // vary
             vary(res, 'Accept-Encoding');
             // content-length below threshold
             if (Number(res.getHeader('Content-Length')) < threshold ||
-                (length !== undefined && length < threshold)) {
-                nocompress('size below threshold');
-                return;
+                (bodyLength !== undefined && bodyLength < threshold)) {
+                return nocompress('size below threshold');
             }
             const encoding = res.getHeader('Content-Encoding') || 'identity';
             // already encoded
             if (encoding !== 'identity') {
-                nocompress('already encoded');
-                return;
+                return nocompress('already encoded');
             }
             // head
             if (req.method === 'HEAD') {
-                nocompress('HEAD request');
-                return;
+                return nocompress('HEAD request');
             }
             // compression method
             // Get all client-accepted encodings, then pick the first one from our preferred order
@@ -180,9 +202,28 @@ export function compressionMiddleware(options) {
             }
             // negotiation failed
             if (!method || method === 'identity') {
-                nocompress('not acceptable');
-                return;
+                return nocompress('not acceptable');
             }
+            return method;
+        }
+        // Release the compression stream when the response closes, freeing native
+        // zlib memory even if the client disconnected before the response finished.
+        // Registered before onHeaders so a close that happens before the stream
+        // exists is not missed (the `closed` flag below handles a stream created
+        // afterwards). Fixes CVE-2026-87776 / GHSA-vc2v-76pw-4v95.
+        // We use `stream.destroy()` (not the `destroy` npm package upstream added)
+        // because our Node target frees the zlib handle on destroy().
+        _on.call(res, 'close', function onResponseClose() {
+            closed = true;
+            stream?.destroy();
+        });
+        onHeaders(res, function onResponseHeaders() {
+            // The sync path has already handled this response (compressed it, or declined to)
+            if (decided)
+                return;
+            const method = decide(length);
+            if (!method)
+                return;
             // compression stream
             if (method === 'zstd') {
                 stream = zlib.createZstdCompress(optsZstd);
@@ -236,6 +277,19 @@ export function shouldCompress(_req, res) {
     }
     return true;
 }
+/**
+ * Compresses a whole body in one call, on the event loop.
+ * Same codec options as the streams, so the output is identical to the streamed one.
+ */
+function compressSync(method, body, opts) {
+    if (method === 'zstd')
+        return zlib.zstdCompressSync(body, opts.zstd);
+    if (method === 'br')
+        return zlib.brotliCompressSync(body, opts.brotli);
+    if (method === 'gzip')
+        return zlib.gzipSync(body, opts.zlib);
+    return zlib.deflateSync(body, opts.zlib);
+}
 function addListeners(stream, on, listeners) {
     for (const [type, listener] of listeners) {
         on.call(stream, type, listener);

package/dist/server/serverStatusMiddleware.d.ts

@@ -1,3 +1,3 @@
 import type { BackendRequestHandler } from './server.model.js';
-export declare function serverStatusMiddleware(projectDir?: string, extra?: any): BackendRequestHandler;
-export declare function getServerStatusData(projectDir?: string, extra?: any): Record<string, any>;
+export declare function serverStatusMiddleware(extra?: any): BackendRequestHandler;
+export declare function getServerStatusData(extra?: any): Record<string, any>;

package/dist/server/serverStatusMiddleware.js

@@ -2,31 +2,22 @@ import os from 'node:os';
 import { localTime } from '@naturalcycles/js-lib/datetime/localTime.js';
 import { _filterNullishValues } from '@naturalcycles/js-lib/object/object.util.js';
 import { memoryUsageFull, processSharedUtil } from '@naturalcycles/nodejs-lib';
-import { getDeployInfo } from '../deploy/deployInfo.util.js';
 const { versions, arch, platform } = process;
 const availableParallelismAtStart = os.availableParallelism();
-const { GAE_APPLICATION, GAE_SERVICE, GAE_VERSION, GOOGLE_CLOUD_PROJECT, K_SERVICE, K_REVISION, APP_ENV, NODE_ENV, NODE_OPTIONS, UV_THREADPOOL_SIZE, MALLOC_ARENA_MAX, DEPLOY_BUILD_TIME, BUILD_VERSION, } = process.env;
-export function serverStatusMiddleware(projectDir, extra) {
+const { GOOGLE_CLOUD_PROJECT, K_SERVICE, K_REVISION, APP_ENV, NODE_ENV, NODE_OPTIONS, UV_THREADPOOL_SIZE, MALLOC_ARENA_MAX, DEPLOY_BUILD_TIME, BUILD_VERSION, } = process.env;
+export function serverStatusMiddleware(extra) {
     return async (_req, res) => {
-        res.json(getServerStatusData(projectDir, extra));
+        res.json(getServerStatusData(extra));
     };
 }
-export function getServerStatusData(projectDir = process.cwd(), extra) {
-    let deployBuildTime = DEPLOY_BUILD_TIME;
-    if (!deployBuildTime) {
-        const { ts } = getDeployInfo(projectDir);
-        deployBuildTime = localTime(ts).toPretty();
-    }
+export function getServerStatusData(extra) {
     const availableParallelism = os.availableParallelism();
     return _filterNullishValues({
         nodeProcessStarted: getStartedStr(),
-        deployBuildTime,
+        DEPLOY_BUILD_TIME,
         BUILD_VERSION,
         APP_ENV,
         GOOGLE_CLOUD_PROJECT,
-        GAE_APPLICATION,
-        GAE_SERVICE,
-        GAE_VERSION,
         K_SERVICE,
         K_REVISION,
         processInfo: {

package/dist/util.d.ts

@@ -1,2 +1 @@
-export declare function isGAE(): boolean;
 export declare function isCloudRun(): boolean;

package/dist/util.js

@@ -1,7 +1,4 @@
-const { GAE_INSTANCE, K_SERVICE } = process.env;
-export function isGAE() {
-    return !!GAE_INSTANCE;
-}
+const { K_SERVICE } = process.env;
 export function isCloudRun() {
     return !!K_SERVICE;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/backend-lib",
   "type": "module",
-  "version": "9.78.0",
+  "version": "9.80.0",
   "dependencies": {
     "@naturalcycles/db-lib": "^10",
     "@naturalcycles/js-lib": "^15",
@@ -20,8 +20,7 @@
   },
   "peerDependencies": {
     "@sentry/node-core": "^10",
-    "firebase-admin": "^14",
-    "simple-git": "^4"
+    "firebase-admin": "^14"
   },
   "peerDependenciesMeta": {
     "@sentry/node-core": {
@@ -29,9 +28,6 @@
     },
     "firebase-admin": {
       "optional": true
-    },
-    "simple-git": {
-      "optional": true
     }
   },
   "devDependencies": {
@@ -68,9 +64,6 @@
     "!src/**/__exclude"
   ],
   "bin": {
-    "deploy-gae": "bin/deploy-gae.js",
-    "undeploy-gae": "bin/undeploy-gae.js",
-    "deploy-prepare": "bin/deploy-prepare.js",
     "deploy-health-check": "bin/deploy-health-check.js"
   },
   "types": "dist/index.d.ts",
@@ -85,7 +78,7 @@
   "engines": {
     "node": ">=24.10.0"
   },
-  "description": "Standard library for making Express.js / AppEngine based backend services",
+  "description": "Standard library for making Express.js based backend services",
   "author": "Natural Cycles Team",
   "license": "MIT",
   "scripts": {
@@ -97,9 +90,6 @@
     "check": "dev-lib check",
     "typecheck": "dev-lib typecheck",
     "dev": "APP_ENV=dev tsx watch src/test/server/server.ts",
-    "deploy-gae": "tsx src/bin/deploy-gae.ts",
-    "deploy-prepare": "tsx src/bin/deploy-prepare.ts",
-    "deploy-prepare-debug": "AA=AA1 BB=BB1 tsx src/bin/deploy-prepare.ts --projectDir ./src/test/project",
     "deploy-health-check-debug1": "tsx src/bin/deploy-health-check.ts --url https://api-master.naturalcycles.com",
     "deploy-health-check-debug2": "tsx src/bin/deploy-health-check.ts --url https://api-master2.naturalcycles.com --thresholdUnhealthy 5"
   }

package/src/deploy/deployHealthCheck.ts

@@ -10,7 +10,6 @@ import { pDelay } from '@naturalcycles/js-lib/promise/pDelay.js'
 import type { UnixTimestampMillis } from '@naturalcycles/js-lib/types'
 import type { CliOptions } from '@naturalcycles/nodejs-lib/args'
 import { dimGrey, red } from '@naturalcycles/nodejs-lib/colors'
-import { exec2 } from '@naturalcycles/nodejs-lib/exec2'
 import { coloredHttpCode } from '../server/request.log.util.js'
 
 export interface DeployHealthCheckOptions {
@@ -19,11 +18,6 @@ export interface DeployHealthCheckOptions {
   maxTries?: number
   timeoutSec?: number
   intervalSec?: number
-  logOnFailure?: boolean
-  logOnSuccess?: boolean
-  gaeProject?: string
-  gaeService?: string
-  gaeVersion?: string
   authHeader?: string
 }
 
@@ -48,25 +42,6 @@ export const deployHealthCheckCliOptions = {
     type: 'number',
     default: 1,
   },
-  logOnFailure: {
-    type: 'boolean',
-    default: true,
-    desc: 'Show server logs on health check failure (requires gaeProject, gaeService, gaeVersion)',
-  },
-  logOnSuccess: {
-    type: 'boolean',
-    default: false,
-    desc: 'Show server logs on health check success (requires gaeProject, gaeService, gaeVersion)',
-  },
-  gaeProject: {
-    type: 'string',
-  },
-  gaeService: {
-    type: 'string',
-  },
-  gaeVersion: {
-    type: 'string',
-  },
   authHeader: {
     type: 'string',
   },
@@ -81,6 +56,7 @@ const inspectOpt: InspectOptions = {
  * Requires up to `healthyThreshold` consecutive OK responses to succeed.
  * Fails on up to `unhealthyThreshold` consecutive FAIL responses.
  * Fails after maxTries.
+ * Throws on failure.
  */
 export async function deployHealthCheck(
   url: string,
@@ -92,11 +68,6 @@ export async function deployHealthCheck(
     maxTries = 30,
     timeoutSec = 30,
     intervalSec = 1,
-    logOnFailure,
-    logOnSuccess,
-    gaeProject,
-    gaeService,
-    gaeVersion,
     authHeader,
   } = opt
 
@@ -116,24 +87,7 @@ export async function deployHealthCheck(
 
   if (failed) {
     console.log(red(`Health check failed!`))
-
-    if (logOnFailure) {
-      try {
-        exec2.spawn(
-          `gcloud app logs read --project ${gaeProject} --service ${gaeService} --version ${gaeVersion}`,
-        )
-      } catch {}
-    }
-
-    process.exit(1)
-  }
-
-  if (logOnSuccess) {
-    try {
-      exec2.spawn(
-        `gcloud app logs read --project ${gaeProject} --service ${gaeService} --version ${gaeVersion}`,
-      )
-    } catch {}
+    throw new Error(`Health check failed: ${doneReason}`)
   }
 
   async function makeAttempt(): Promise<void> {

package/src/deploy/index.ts

@@ -1,21 +1,6 @@
-import type { BackendCfg } from './backend.cfg.util.js'
-import { getBackendCfg } from './backend.cfg.util.js'
-import type { DeployInfo } from './deploy.model.js'
-import { createAppYaml, createDeployInfo } from './deploy.util.js'
-import { deployGae } from './deployGae.js'
 import type { DeployHealthCheckOptions } from './deployHealthCheck.js'
 import { deployHealthCheck } from './deployHealthCheck.js'
-import { deployPrepare } from './deployPrepare.js'
 
-export type { BackendCfg, DeployHealthCheckOptions, DeployInfo }
+export type { DeployHealthCheckOptions }
 
-export {
-  createAppYaml,
-  createDeployInfo,
-  deployGae,
-  deployHealthCheck,
-  deployPrepare,
-  getBackendCfg,
-}
-
-export * from './deployInfo.util.js'
+export { deployHealthCheck }

package/src/express/createDefaultApp.ts

@@ -14,10 +14,10 @@ import type {
   BackendRequestHandler,
 } from '../server/server.model.js'
 import { simpleRequestLoggerMiddleware } from '../server/simpleRequestLoggerMiddleware.js'
-import { isGAE } from '../util.js'
 
 const isTest = process.env['APP_ENV'] === 'test'
 const isDev = process.env['APP_ENV'] === 'dev'
+const isGAE = !!process.env['GAE_INSTANCE']
 
 export async function createDefaultApp(cfg: DefaultAppCfg): Promise<BackendApplication> {
   const { sentryService } = cfg
@@ -69,7 +69,7 @@ export async function createDefaultApp(cfg: DefaultAppCfg): Promise<BackendAppli
     }),
   )
 
-  if (!isGAE() && isTest) {
+  if (!isGAE && isTest) {
     // compression is not used in AppEngine, because AppEngine provides it by default
     app.use(compressionMiddleware())
   }