Backend is stack, extract APIs.

Author: taeold

spec/runtime/loader.spec.ts

@@ -3,7 +3,11 @@ import * as path from 'path';
 import * as semver from 'semver';
 
 import * as loader from '../../src/runtime/loader';
-import { ManifestBackend, ManifestEndpoint } from '../../src/runtime/manifest';
+import {
+ ManifestStack,
+ ManifestEndpoint,
+ ManifestRequiredAPI,
+} from '../../src/runtime/manifest';
 
 function annotatedFn(
  endpoint: ManifestEndpoint
@@ -27,15 +31,16 @@ const EVENT_ENDPOINT = {
  },
 };
 
-describe('extractEndpoints', () => {
- it('extracts endpoints from a simple module', () => {
+describe('extractStack', () => {
+ it('extracts stack from a simple module', () => {
  const module = {
  fn1: annotatedFn(HTTP_ENDPOINT),
  fn2: annotatedFn(EVENT_ENDPOINT),
  };
 
  const endpoints: Record<string, ManifestEndpoint> = {};
- loader.extractEndpoints(module, endpoints);
+ const requiredAPIs: Record<string, ManifestRequiredAPI> = {};
+ loader.extractStack(module, endpoints, requiredAPIs);
  expect(endpoints).to.be.deep.equal({
  fn1: {
  entryPoint: 'fn1',
@@ -48,7 +53,7 @@ describe('extractEndpoints', () => {
  });
  });
 
- it('extracts endpoints from a module with group functions', () => {
+ it('extracts stack from a module with group functions', () => {
  const module = {
  fn1: annotatedFn(HTTP_ENDPOINT),
  g1: {
@@ -57,7 +62,8 @@ describe('extractEndpoints', () => {
  };
 
  const endpoints: Record<string, ManifestEndpoint> = {};
- loader.extractEndpoints(module, endpoints);
+ const requiredAPIs: Record<string, ManifestRequiredAPI> = {};
+ loader.extractStack(module, endpoints, requiredAPIs);
  expect(endpoints).to.be.deep.equal({
  fn1: {
  entryPoint: 'fn1',
@@ -71,8 +77,8 @@ describe('extractEndpoints', () => {
  });
 });
 
-describe('loadBackend', () => {
- const expected: ManifestBackend = {
+describe('loadStack', () => {
+ const expected: ManifestStack = {
  endpoints: {
  v1http: {
  platform: 'gcfv1',
@@ -86,31 +92,32 @@ describe('loadBackend', () => {
  callableTrigger: {},
  },
  },
- requiredAPIs: {},
+ requiredAPIs: [],
  specVersion: 'v1alpha1',
  };
 
  type Testcase = {
  name: string;
  modulePath: string;
- expected: ManifestBackend;
+ expected: ManifestStack;
  };
 
  function runTests(tc: Testcase) {
  it('loads backend given relative path', async () => {
- await expect(loader.loadBackend(tc.modulePath)).to.eventually.deep.equal(
+ await expect(loader.loadStack(tc.modulePath)).to.eventually.deep.equal(
  tc.expected
  );
  });
 
  it('loads backend given absolute path', async () => {
  await expect(
- loader.loadBackend(path.join(process.cwd(), tc.modulePath))
+ loader.loadStack(path.join(process.cwd(), tc.modulePath))
  ).to.eventually.deep.equal(tc.expected);
  });
  }
 
  let prev;
+
  beforeEach(() => {
  // TODO: When __trigger annotation is removed and GCLOUD_PROJECT is not required at runtime, remove this.
  prev = process.env.GCLOUD_PROJECT;
@@ -150,7 +157,7 @@ describe('loadBackend', () => {
  callableTrigger: {},
  },
  },
- requiredAPIs: {},
+ requiredAPIs: [],
  specVersion: 'v1alpha1',
  },
  },
@@ -170,10 +177,16 @@ describe('loadBackend', () => {
  },
  },
  },
- requiredAPIs: {
- pubsub: 'pubsub.googleapis.com',
- scheduler: 'cloudscheduler.googleapis.com',
- },
+ requiredAPIs: [
+ {
+ api: 'pubsub.googleapis.com',
+ reason: 'Needed for v1 scheduled functions.',
+ },
+ {
+ api: 'cloudscheduler.googleapis.com',
+ reason: 'Needed for v1 scheduled functions.',
+ },
+ ],
  specVersion: 'v1alpha1',
  },
  },

src/bin/firebase-functions.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import * as express from 'express';
-import { loadBackend } from '../runtime/loader';
+import { loadStack } from '../runtime/loader';
 
 function printUsage() {
  console.error(
@@ -24,9 +24,9 @@ const functionsDir = args[0];
 let server;
 const app = express();
 
-app.get('/backend.yaml', async (req, res) => {
+app.get('/stack.yaml', async (req, res) => {
  try {
- const backend = await loadBackend(functionsDir);
+ const backend = await loadStack(functionsDir);
  res.setHeader('content-type', 'text/yaml');
  res.send(JSON.stringify(backend));
  } catch (e) {
@@ -36,14 +36,14 @@ app.get('/backend.yaml', async (req, res) => {
  }
 });
 
-app.get('/quitquitquit', async (req, res) => {
+app.get('/__/quitquitquit', async (req, res) => {
  res.send('ok');
  server.close(() => console.log('shutdown requested via /quitquitquit'));
 });
 
 let port = 8080;
-if (process.env.ADMIN_PORT) {
- port = Number.parseInt(process.env.ADMIN_PORT);
+if (process.env.STACK_CONTROL_API_PORT) {
+ port = Number.parseInt(process.env.STACK_CONTROL_API_PORT);
 }
 
 console.log('Serving at port', port);

src/runtime/loader.ts

@@ -22,7 +22,11 @@
 import * as url from 'url';
 import * as path from 'path';
 
-import { ManifestBackend, ManifestEndpoint } from './manifest';
+import {
+ ManifestStack,
+ ManifestEndpoint,
+ ManifestRequiredAPI,
+} from './manifest';
 
 /**
  * Dynamically load import function to prevent TypeScript from
@@ -54,9 +58,10 @@ async function loadModule(functionsDir: string) {
 }
 
 /* @internal */
-export function extractEndpoints(
+export function extractStack(
  module,
  endpoints: Record<string, ManifestEndpoint>,
+ requiredAPIs: Record<string, ManifestRequiredAPI>,
  prefix = ''
 ) {
  for (const [name, val] of Object.entries(module)) {
@@ -70,29 +75,35 @@ export function extractEndpoints(
  ...val['__endpoint'],
  entryPoint: funcName.replace(/-/g, '.'),
  };
+ if (val['__requiredAPIs'] && Array.isArray(val['__requiredAPIs'])) {
+ for (const { api, reason } of val['__requiredAPIs']) {
+ const reasons = [reason];
+ if (requiredAPIs[api]?.reason) {
+ reasons.push(requiredAPIs[api].reason);
+ }
+ requiredAPIs[api] = { api, reason: reasons.join(' ') };
+ }
+ }
  } else if (typeof val === 'object' && val !== null) {
- extractEndpoints(val, endpoints, prefix + name + '-');
+ extractStack(val, endpoints, requiredAPIs, prefix + name + '-');
  }
  }
 }
 
 /* @internal */
-export async function loadBackend(
+export async function loadStack(
  functionsDir: string
-): Promise<ManifestBackend> {
+): Promise<ManifestStack> {
  const endpoints: Record<string, ManifestEndpoint> = {};
+ const requiredAPIs: Record<string, ManifestRequiredAPI> = {};
  const mod = await loadModule(functionsDir);
 
- extractEndpoints(mod, endpoints);
+ extractStack(mod, endpoints, requiredAPIs);
 
- const backend: ManifestBackend = {
+ const stack: ManifestStack = {
  endpoints,
  specVersion: 'v1alpha1',
- requiredAPIs: {},
+ requiredAPIs: Object.values(requiredAPIs),
  };
- if (Object.values(endpoints).find((ep) => ep.scheduleTrigger)) {
- backend.requiredAPIs['pubsub'] = 'pubsub.googleapis.com';
- backend.requiredAPIs['scheduler'] = 'cloudscheduler.googleapis.com';
- }
- return backend;
+ return stack;
 }

src/runtime/manifest.ts

@@ -68,12 +68,18 @@ export interface ManifestEndpoint {
  };
 }
 
+/* @internal */
+export interface ManifestRequiredAPI {
+ api: string;
+ reason: string;
+}
+
 /**
  * @internal
  * An definition of a function deployment as appears in the Manifest.
  **/
-export interface ManifestBackend {
+export interface ManifestStack {
  specVersion: 'v1alpha1';
- requiredAPIs: Record<string, string>;
+ requiredAPIs: ManifestRequiredAPI[];
  endpoints: Record<string, ManifestEndpoint>;
 }