@gapi/core 1.8.222 → 1.8.223

package/dist/index.d.ts

@@ -11,5 +11,6 @@ export * from '@rxdi/graphql-pubsub';
 export { withFilter } from '@rxdi/graphql-rabbitmq-subscriptions';
 export * from '@rxdi/hapi';
 export * from 'graphql';
+export { awaitLambdaModule, Bootstrap, deliverLambdaModule, isLambdaModuleDelivered, isLambdaRuntime, resetLambdaBridge, } from './lambda-bridge';
 export { buildSchema, ExecutionResult, extendSchema, isSpecifiedScalarType, } from 'graphql';
 export { FilterFn, PubSubEngine, PubSubOptions, ResolverFn, } from 'graphql-subscriptions';

package/dist/index.js

@@ -21,7 +21,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 var CoreModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PubSubEngine = exports.isSpecifiedScalarType = exports.extendSchema = exports.buildSchema = exports.withFilter = exports.GeoJSON = exports.CoreModule = void 0;
+exports.PubSubEngine = exports.isSpecifiedScalarType = exports.extendSchema = exports.buildSchema = exports.resetLambdaBridge = exports.isLambdaRuntime = exports.isLambdaModuleDelivered = exports.deliverLambdaModule = exports.Bootstrap = exports.awaitLambdaModule = exports.withFilter = exports.GeoJSON = exports.CoreModule = void 0;
 const core_1 = require("@rxdi/core");
 const graphql_1 = require("@rxdi/graphql");
 const graphql_pubsub_1 = require("@rxdi/graphql-pubsub");
@@ -56,6 +56,16 @@ var graphql_rabbitmq_subscriptions_1 = require("@rxdi/graphql-rabbitmq-subscript
 Object.defineProperty(exports, "withFilter", { enumerable: true, get: function () { return graphql_rabbitmq_subscriptions_1.withFilter; } });
 __exportStar(require("@rxdi/hapi"), exports);
 __exportStar(require("graphql"), exports);
+// Explicit re-export of the lambda-aware Bootstrap MUST come after the
+// `export * from '@rxdi/core'` above so it shadows the upstream Bootstrap.
+// Outside Lambforge (LAMBFORGE_RUNTIME unset), this delegates verbatim.
+var lambda_bridge_1 = require("./lambda-bridge");
+Object.defineProperty(exports, "awaitLambdaModule", { enumerable: true, get: function () { return lambda_bridge_1.awaitLambdaModule; } });
+Object.defineProperty(exports, "Bootstrap", { enumerable: true, get: function () { return lambda_bridge_1.Bootstrap; } });
+Object.defineProperty(exports, "deliverLambdaModule", { enumerable: true, get: function () { return lambda_bridge_1.deliverLambdaModule; } });
+Object.defineProperty(exports, "isLambdaModuleDelivered", { enumerable: true, get: function () { return lambda_bridge_1.isLambdaModuleDelivered; } });
+Object.defineProperty(exports, "isLambdaRuntime", { enumerable: true, get: function () { return lambda_bridge_1.isLambdaRuntime; } });
+Object.defineProperty(exports, "resetLambdaBridge", { enumerable: true, get: function () { return lambda_bridge_1.resetLambdaBridge; } });
 var graphql_2 = require("graphql");
 Object.defineProperty(exports, "buildSchema", { enumerable: true, get: function () { return graphql_2.buildSchema; } });
 Object.defineProperty(exports, "extendSchema", { enumerable: true, get: function () { return graphql_2.extendSchema; } });

package/dist/lambda-bridge.d.ts

@@ -0,0 +1,35 @@
+import { ConfigModel, ObservableContainer } from '@rxdi/core';
+import { Observable } from 'rxjs';
+export declare function isLambdaRuntime(): boolean;
+/**
+ * Synchronous check: did a user bundle already deliver its AppModule via
+ * the bridge? Useful right after `await import(userBundle)` to decide
+ * between the new (Bootstrap-based) and legacy (default-export-function)
+ * specialize paths without paying a Promise-race timeout.
+ */
+export declare function isLambdaModuleDelivered(): boolean;
+/**
+ * Called by the host (e.g. FissionPlugin) before loading the user bundle.
+ * Returns a Promise that resolves with the user's AppModule once the
+ * lambda-aware Bootstrap intercepts it.
+ */
+export declare function awaitLambdaModule(): Promise<Function>;
+/**
+ * Called by the lambda-aware Bootstrap wrapper to hand the user's AppModule
+ * to the waiting host. If the host hasn't called `awaitLambdaModule()` yet,
+ * we cache the module so the next caller gets it.
+ */
+export declare function deliverLambdaModule(appModule: Function): void;
+/**
+ * Resets bridge state. Useful for tests and (eventually) re-specialization
+ * if a single container ever needs to load more than one user bundle.
+ */
+export declare function resetLambdaBridge(): void;
+/**
+ * Drop-in replacement for `@rxdi/core` Bootstrap that detects Lambforge mode
+ * via env. In lambda mode, the AppModule is delivered to the bridge and a
+ * dummy observable resolves so user code's `.subscribe(...)` still fires
+ * (which lets `console.log('Server started')` style callbacks run as the
+ * user expects). In normal mode, this is exactly the upstream Bootstrap.
+ */
+export declare function Bootstrap(app: Function, config?: ConfigModel): Observable<ObservableContainer>;

package/dist/lambda-bridge.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLambdaRuntime = isLambdaRuntime;
+exports.isLambdaModuleDelivered = isLambdaModuleDelivered;
+exports.awaitLambdaModule = awaitLambdaModule;
+exports.deliverLambdaModule = deliverLambdaModule;
+exports.resetLambdaBridge = resetLambdaBridge;
+exports.Bootstrap = Bootstrap;
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+const core_1 = require("@rxdi/core");
+const rxjs_1 = require("rxjs");
+/**
+ * Lambda bridge for Lambforge (or any host that pre-bootstraps a gapi
+ * runtime and later wants the user's AppModule applied in-place).
+ *
+ * In a normal process, `Bootstrap(AppModule)` starts the whole framework.
+ * Inside a Lambforge container the framework is already running — the user's
+ * AppModule needs to be wired into the live container rather than starting
+ * a fresh one. The host (FissionPlugin) calls `awaitLambdaModule()` after
+ * loading the user bundle; when the user bundle's `Bootstrap(AppModule)`
+ * fires, the env-gated wrapper delivers the module reference here, and the
+ * host applies it via `BootstrapService.applyModule`.
+ *
+ * Activation: set `LAMBFORGE_RUNTIME=1` in the container's process env
+ * BEFORE `require()`ing the user bundle. The user's source code is
+ * unchanged — `Bootstrap(AppModule).subscribe(...)` works in both modes.
+ */
+let pendingResolver = null;
+let pendingPromise = null;
+let pendingDelivered = null;
+function isLambdaRuntime() {
+    return process.env.LAMBFORGE_RUNTIME === '1';
+}
+/**
+ * Synchronous check: did a user bundle already deliver its AppModule via
+ * the bridge? Useful right after `await import(userBundle)` to decide
+ * between the new (Bootstrap-based) and legacy (default-export-function)
+ * specialize paths without paying a Promise-race timeout.
+ */
+function isLambdaModuleDelivered() {
+    return pendingDelivered !== null;
+}
+/**
+ * Called by the host (e.g. FissionPlugin) before loading the user bundle.
+ * Returns a Promise that resolves with the user's AppModule once the
+ * lambda-aware Bootstrap intercepts it.
+ */
+function awaitLambdaModule() {
+    if (pendingDelivered) {
+        return Promise.resolve(pendingDelivered);
+    }
+    if (pendingPromise) {
+        return pendingPromise;
+    }
+    pendingPromise = new Promise((resolve) => {
+        pendingResolver = resolve;
+    });
+    return pendingPromise;
+}
+/**
+ * Called by the lambda-aware Bootstrap wrapper to hand the user's AppModule
+ * to the waiting host. If the host hasn't called `awaitLambdaModule()` yet,
+ * we cache the module so the next caller gets it.
+ */
+function deliverLambdaModule(appModule) {
+    if (pendingResolver) {
+        pendingResolver(appModule);
+        pendingResolver = null;
+        pendingPromise = null;
+        pendingDelivered = appModule;
+        return;
+    }
+    pendingDelivered = appModule;
+    pendingPromise = Promise.resolve(appModule);
+}
+/**
+ * Resets bridge state. Useful for tests and (eventually) re-specialization
+ * if a single container ever needs to load more than one user bundle.
+ */
+function resetLambdaBridge() {
+    pendingResolver = null;
+    pendingPromise = null;
+    pendingDelivered = null;
+}
+/**
+ * Drop-in replacement for `@rxdi/core` Bootstrap that detects Lambforge mode
+ * via env. In lambda mode, the AppModule is delivered to the bridge and a
+ * dummy observable resolves so user code's `.subscribe(...)` still fires
+ * (which lets `console.log('Server started')` style callbacks run as the
+ * user expects). In normal mode, this is exactly the upstream Bootstrap.
+ */
+function Bootstrap(app, config) {
+    if (isLambdaRuntime()) {
+        deliverLambdaModule(app);
+        return new rxjs_1.Observable((subscriber) => {
+            subscriber.next(core_1.Container);
+            subscriber.complete();
+        });
+    }
+    return (0, core_1.Bootstrap)(app, config);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gapi/core",
-  "version": "1.8.222",
+  "version": "1.8.223",
   "repository": {
     "type": "git",
     "url": "https://github.com/Stradivario/gapi.git"
@@ -25,10 +25,10 @@
     "url": "https://github.com/Stradivario/gapi/issues"
   },
   "dependencies": {
-    "@rxdi/core": "^0.7.244",
-    "@rxdi/graphql": "^0.7.244",
-    "@rxdi/graphql-pubsub": "^0.7.244",
-    "@rxdi/hapi": "^0.7.244",
+    "@rxdi/core": "^0.7.245",
+    "@rxdi/graphql": "^0.7.245",
+    "@rxdi/graphql-pubsub": "^0.7.245",
+    "@rxdi/hapi": "^0.7.245",
     "graphql": "^16.12.0"
   },
   "main": "./dist/index.js",

package/src/index.ts

@@ -30,6 +30,17 @@ export * from '@rxdi/graphql-pubsub';
 export { withFilter } from '@rxdi/graphql-rabbitmq-subscriptions';
 export * from '@rxdi/hapi';
 export * from 'graphql';
+// Explicit re-export of the lambda-aware Bootstrap MUST come after the
+// `export * from '@rxdi/core'` above so it shadows the upstream Bootstrap.
+// Outside Lambforge (LAMBFORGE_RUNTIME unset), this delegates verbatim.
+export {
+  awaitLambdaModule,
+  Bootstrap,
+  deliverLambdaModule,
+  isLambdaModuleDelivered,
+  isLambdaRuntime,
+  resetLambdaBridge,
+} from './lambda-bridge';
 export {
   buildSchema,
   ExecutionResult,

package/src/lambda-bridge.ts

@@ -0,0 +1,109 @@
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+import {
+  Bootstrap as RxdiBootstrap,
+  ConfigModel,
+  Container,
+  ObservableContainer,
+} from '@rxdi/core';
+import { Observable } from 'rxjs';
+
+/**
+ * Lambda bridge for Lambforge (or any host that pre-bootstraps a gapi
+ * runtime and later wants the user's AppModule applied in-place).
+ *
+ * In a normal process, `Bootstrap(AppModule)` starts the whole framework.
+ * Inside a Lambforge container the framework is already running — the user's
+ * AppModule needs to be wired into the live container rather than starting
+ * a fresh one. The host (FissionPlugin) calls `awaitLambdaModule()` after
+ * loading the user bundle; when the user bundle's `Bootstrap(AppModule)`
+ * fires, the env-gated wrapper delivers the module reference here, and the
+ * host applies it via `BootstrapService.applyModule`.
+ *
+ * Activation: set `LAMBFORGE_RUNTIME=1` in the container's process env
+ * BEFORE `require()`ing the user bundle. The user's source code is
+ * unchanged — `Bootstrap(AppModule).subscribe(...)` works in both modes.
+ */
+
+let pendingResolver: ((module: Function) => void) | null = null;
+let pendingPromise: Promise<Function> | null = null;
+let pendingDelivered: Function | null = null;
+
+export function isLambdaRuntime(): boolean {
+  return process.env.LAMBFORGE_RUNTIME === '1';
+}
+
+/**
+ * Synchronous check: did a user bundle already deliver its AppModule via
+ * the bridge? Useful right after `await import(userBundle)` to decide
+ * between the new (Bootstrap-based) and legacy (default-export-function)
+ * specialize paths without paying a Promise-race timeout.
+ */
+export function isLambdaModuleDelivered(): boolean {
+  return pendingDelivered !== null;
+}
+
+/**
+ * Called by the host (e.g. FissionPlugin) before loading the user bundle.
+ * Returns a Promise that resolves with the user's AppModule once the
+ * lambda-aware Bootstrap intercepts it.
+ */
+export function awaitLambdaModule(): Promise<Function> {
+  if (pendingDelivered) {
+    return Promise.resolve(pendingDelivered);
+  }
+  if (pendingPromise) {
+    return pendingPromise;
+  }
+  pendingPromise = new Promise<Function>((resolve) => {
+    pendingResolver = resolve;
+  });
+  return pendingPromise;
+}
+
+/**
+ * Called by the lambda-aware Bootstrap wrapper to hand the user's AppModule
+ * to the waiting host. If the host hasn't called `awaitLambdaModule()` yet,
+ * we cache the module so the next caller gets it.
+ */
+export function deliverLambdaModule(appModule: Function): void {
+  if (pendingResolver) {
+    pendingResolver(appModule);
+    pendingResolver = null;
+    pendingPromise = null;
+    pendingDelivered = appModule;
+    return;
+  }
+  pendingDelivered = appModule;
+  pendingPromise = Promise.resolve(appModule);
+}
+
+/**
+ * Resets bridge state. Useful for tests and (eventually) re-specialization
+ * if a single container ever needs to load more than one user bundle.
+ */
+export function resetLambdaBridge(): void {
+  pendingResolver = null;
+  pendingPromise = null;
+  pendingDelivered = null;
+}
+
+/**
+ * Drop-in replacement for `@rxdi/core` Bootstrap that detects Lambforge mode
+ * via env. In lambda mode, the AppModule is delivered to the bridge and a
+ * dummy observable resolves so user code's `.subscribe(...)` still fires
+ * (which lets `console.log('Server started')` style callbacks run as the
+ * user expects). In normal mode, this is exactly the upstream Bootstrap.
+ */
+export function Bootstrap(
+  app: Function,
+  config?: ConfigModel,
+): Observable<ObservableContainer> {
+  if (isLambdaRuntime()) {
+    deliverLambdaModule(app);
+    return new Observable<ObservableContainer>((subscriber) => {
+      subscriber.next(Container as ObservableContainer);
+      subscriber.complete();
+    });
+  }
+  return RxdiBootstrap(app, config);
+}