;
56 | }
57 |
58 | export abstract class SecureResource extends Resource {
59 | protected abstract permsToActions(...perms: P[]): ActionsList;
60 |
61 | protected registerPolicy(...perms: P[]): void {
62 | const req = new ResourceDeclareRequest();
63 | const policyResource = new ProtoResource();
64 | policyResource.setType(ResourceType.POLICY);
65 |
66 | // Send an unnamed function as the principle. This is interpreted to mean the currently running function, making the request.
67 | const policy = new PolicyResource();
68 | const defaultPrincipal = new ProtoResource();
69 | defaultPrincipal.setType(ResourceType.SERVICE);
70 | policy.setPrincipalsList([defaultPrincipal]);
71 |
72 | // Convert the permissions to an action set.
73 | const actions = this.permsToActions(...perms);
74 | policy.setActionsList(actions);
75 |
76 | req.setId(policyResource);
77 | req.setPolicy(policy);
78 |
79 | this.registerPromise.then((resource) => {
80 | policy.setResourcesList([resource]);
81 |
82 | resourceClient.declare(req, (error) => {
83 | if (error) {
84 | throw fromGrpcError(error);
85 | }
86 | });
87 | });
88 | }
89 | }
90 |
91 | // This singleton helps avoid duplicate references to bucket('name')
92 | // will return the same bucket resource
93 | const cache: Record> = {};
94 |
95 | export type newer = (name: string, ...args: any[]) => T;
96 |
97 | /**
98 | * Provides a new resource instance.
99 | *
100 | * @param T the type of resource to construct
101 | * @returns the resource
102 | */
103 | export const make = (
104 | T: new (name: string, ...args: any[]) => T
105 | ): newer => {
106 | const typename = T.name;
107 | return (name: string, ...args: any[]) => {
108 | if (!cache[typename]) {
109 | cache[typename] = {};
110 | }
111 | if (!cache[typename][name]) {
112 | cache[typename][name] = new T(name, ...args);
113 |
114 | const prom = cache[typename][name]['register']();
115 |
116 | cache[typename][name]['registerPromise'] = prom;
117 |
118 | prom.catch((err) => {
119 | console.error(err);
120 | });
121 | }
122 | return cache[typename][name] as T;
123 | };
124 | };
125 |
126 | export const toDuration = (seconds: number): Duration => {
127 | const duration = new Duration();
128 | duration.setSeconds(seconds);
129 |
130 | return duration;
131 | };
132 |
133 | export const startStreamHandler = async (
134 | handler: () => Promise>
135 | ): Promise => {
136 | const stream = await handler();
137 |
138 | // Block until the stream has closed...
139 | await new Promise((res) => {
140 | // The server has determined this stream must close
141 | stream.on('end', () => {
142 | console.log('Membrane has terminated the trigger stream');
143 | res();
144 | });
145 | });
146 | };
147 |
--------------------------------------------------------------------------------
/src/resources/http.test.ts:
--------------------------------------------------------------------------------
1 | // Copyright 2021, Nitric Technologies Pty Ltd.
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 | import { HttpWorkerOptions, http } from '.';
15 | import { HttpClient } from '../gen/nitric/proto/http/v1/http_grpc_pb';
16 |
17 | jest.mock('portfinder', () => {
18 | const originalModule = jest.requireActual('portfinder');
19 |
20 | return {
21 | __esmodule: true,
22 | ...originalModule,
23 | getPort: (callback: (err, port) => void) => {
24 | callback('', 1234);
25 | },
26 | };
27 | });
28 |
29 | describe.skip('HTTP Proxy', () => {
30 | const httpProxySpy = jest
31 | .spyOn(HttpClient.prototype, 'proxy')
32 | .mockReturnValue({} as any);
33 |
34 | const mockApp = {
35 | listen: () => {
36 | return {
37 | on: () => {},
38 | } as any;
39 | },
40 | };
41 |
42 | afterAll(() => {
43 | jest.clearAllMocks();
44 | });
45 |
46 | describe.skip('when creating a new http proxy with an app', () => {
47 | let error = undefined;
48 | afterAll(() => {
49 | jest.resetAllMocks();
50 | });
51 |
52 | beforeAll(() => {
53 | try {
54 | http(mockApp);
55 | } catch (err) {
56 | error = err;
57 | }
58 | });
59 |
60 | it('should not return an error', () => {
61 | expect(error).toBe(undefined);
62 | });
63 | });
64 |
65 | describe.skip(`when creating a new http proxy with an app and callback`, () => {
66 | const fakeCallback = () => {};
67 |
68 | afterAll(() => {
69 | jest.resetAllMocks();
70 | });
71 |
72 | beforeAll(async () => {
73 | http(mockApp, fakeCallback);
74 | });
75 |
76 | it('should call HttpClient::proxy()', () => {
77 | expect(httpProxySpy).toBeCalledTimes(1);
78 | });
79 | });
80 |
81 | describe.skip(`when creating a new http proxy with a bootstrap function`, () => {
82 | const fakeFunc = () => {
83 | return {
84 | on: () => {},
85 | } as any;
86 | };
87 | const fakeCallback = () => {};
88 |
89 | afterAll(() => {
90 | jest.resetAllMocks();
91 | });
92 |
93 | beforeAll(async () => {
94 | http(fakeFunc, fakeCallback);
95 | });
96 |
97 | it('should call HttpClient::proxy()', () => {
98 | expect(httpProxySpy).toBeCalledTimes(1);
99 | });
100 | });
101 | });
102 |
--------------------------------------------------------------------------------
/src/resources/http.ts:
--------------------------------------------------------------------------------
1 | // Copyright 2021, Nitric Technologies Pty Ltd.
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | import portfinder from 'portfinder';
16 | import { HttpClient } from '@nitric/proto/http/v1/http_grpc_pb';
17 | import { SERVICE_BIND } from '../constants';
18 | import * as grpc from '@grpc/grpc-js';
19 | import { ClientMessage, HttpProxyRequest } from '@nitric/proto/http/v1/http_pb';
20 |
21 | interface ServerType {
22 | on: (
23 | eventType: 'close',
24 | callback: () => void,
25 | options?: Record
26 | ) => void;
27 | close?: () => void;
28 | }
29 |
30 | type ListenerFunction =
31 | | ((port: number, callback?: () => void) => ServerType | Promise)
32 | | ((port: number) => ServerType | Promise);
33 |
34 | interface NodeApplication {
35 | listen: ListenerFunction;
36 | }
37 |
38 | // eslint-disable-next-line
39 | const NO_OP = () => {};
40 |
41 | export class HttpWorkerOptions {
42 | public readonly app: NodeApplication;
43 | public readonly port: number;
44 | public readonly callback: () => void;
45 |
46 | constructor(
47 | app: NodeApplication,
48 | port: number,
49 | callback: () => void = NO_OP
50 | ) {
51 | this.app = app;
52 | this.port = port;
53 | this.callback = callback;
54 | }
55 | }
56 |
57 | const createWorker = async (
58 | app: NodeApplication,
59 | port: number,
60 | callback?: () => void
61 | ) => {
62 | const httpClient = new HttpClient(
63 | SERVICE_BIND,
64 | grpc.ChannelCredentials.createInsecure()
65 | );
66 |
67 | const httpProxyRequest = new HttpProxyRequest();
68 | httpProxyRequest.setHost(`localhost:${port}`);
69 |
70 | const httpProxyStream = httpClient.proxy();
71 |
72 | httpProxyStream.on('data', NO_OP);
73 |
74 | httpProxyStream.on('error', (err) => {
75 | console.error('An error occurred:', err);
76 | });
77 |
78 | const clientMessage = new ClientMessage();
79 | clientMessage.setRequest(httpProxyRequest);
80 | httpProxyStream.write(clientMessage);
81 | // Start Node application that HTTP proxy sits on
82 | if (process.env.NITRIC_ENVIRONMENT !== 'build') {
83 | const srv = await app.listen(port, callback);
84 |
85 | srv.on('close', () => {
86 | httpProxyStream.cancel();
87 | });
88 |
89 | httpProxyStream.on('end', () => {
90 | if (typeof srv.close === 'function') {
91 | srv.close();
92 | } else {
93 | process.exit(1); // Close the Node.js application with a non-zero exit code
94 | }
95 | });
96 | }
97 | };
98 |
99 | /**
100 | * Register an HTTP Proxy to the provided application.
101 | *
102 | * @param app the http application to run behind the proxy
103 | * @param callback an optional callback to run after the proxy has started
104 | */
105 | export const http = (
106 | app: NodeApplication | ListenerFunction,
107 | callback?: () => void
108 | ): void => {
109 | const unknownApp = app as any;
110 |
111 | const nodeApp =
112 | !!unknownApp.listen && typeof unknownApp.listen === 'function'
113 | ? (app as NodeApplication)
114 | : { listen: app as ListenerFunction };
115 |
116 | const port = Number.parseInt(process.env.NITRIC_HTTP_PROXY_PORT);
117 |
118 | if (!port || Number.isNaN(port)) {
119 | // If port isn't set and the nitric environment is not run or cloud
120 | console.log('NITRIC_HTTP_PROXY_PORT not set. Finding open port...');
121 | portfinder.getPort((err, port) => {
122 | if (err) {
123 | throw new Error(
124 | 'Unable to find open port. Try setting the env var `NITRIC_HTTP_PROXY_PORT`'
125 | );
126 | }
127 |
128 | createWorker(nodeApp, port, callback);
129 | });
130 |
131 | return;
132 | }
133 |
134 | createWorker(nodeApp, port, callback);
135 | };
136 |
--------------------------------------------------------------------------------
/src/resources/index.ts:
--------------------------------------------------------------------------------
1 | // Copyright 2021, Nitric Technologies Pty Ltd.
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 | export * from './api';
15 | export * from './topic';
16 | export * from './queue';
17 | export * from './keyvalue';
18 | export * from './bucket';
19 | export * from './schedule';
20 | export * from './secret';
21 | export * from './sql';
22 | export * from './http';
23 | export * from './websocket';
24 | export * from './batch';
25 | export { oidcRule } from './oidc';
26 |
--------------------------------------------------------------------------------
/src/resources/keyvalue.test.ts:
--------------------------------------------------------------------------------
1 | // Copyright 2021, Nitric Technologies Pty Ltd.
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | import { status, ServiceError, Metadata } from '@grpc/grpc-js';
16 | import { ResourcesClient } from '@nitric/proto/resources/v1/resources_grpc_pb';
17 | import { UnimplementedError } from '../api/errors';
18 | import { kv } from '.';
19 | import { ResourceDeclareResponse } from '@nitric/proto/resources/v1/resources_pb';
20 | import { StoreRef } from '../api/keyvalue/v1/store';
21 |
22 | describe('Registering key/value store resources', () => {
23 | describe('Given declare returns an error from the resource server', () => {
24 | const MOCK_ERROR = {
25 | code: status.UNIMPLEMENTED,
26 | message: 'UNIMPLEMENTED',
27 | };
28 |
29 | const validName = 'my-store';
30 | let declareSpy;
31 |
32 | beforeAll(() => {
33 | jest.spyOn(console, 'error').mockImplementation(() => {});
34 | declareSpy = jest
35 | .spyOn(ResourcesClient.prototype, 'declare')
36 | .mockImplementationOnce((request, callback: any) => {
37 | callback(MOCK_ERROR, null);
38 | 1;
39 | return null as any;
40 | });
41 | });
42 |
43 | afterAll(() => {
44 | jest.restoreAllMocks();
45 | });
46 |
47 | it('Should throw the error', async () => {
48 | await expect(kv(validName)['registerPromise']).rejects.toBeInstanceOf(
49 | UnimplementedError
50 | );
51 | });
52 |
53 | it('Should call the resource server', () => {
54 | expect(declareSpy).toBeCalledTimes(1);
55 | });
56 | });
57 |
58 | describe('Given declare succeeds on the resource server', () => {
59 | describe('When the service succeeds', () => {
60 | const validName = 'my-store2';
61 | let otherSpy;
62 |
63 | beforeAll(() => {
64 | otherSpy = jest
65 | .spyOn(ResourcesClient.prototype, 'declare')
66 | .mockImplementationOnce((request, callback: any) => {
67 | const response = new ResourceDeclareResponse();
68 | callback(null, response);
69 | return null as any;
70 | });
71 | });
72 |
73 | afterAll(() => {
74 | jest.resetAllMocks();
75 | });
76 |
77 | it('Should succeed', async () => {
78 | await expect(kv(validName)['registerPromise']).resolves.not.toBeNull();
79 | });
80 |
81 | it('Should call the resource server', () => {
82 | expect(otherSpy).toBeCalledTimes(1);
83 | });
84 | });
85 | });
86 |
87 | describe('Given a store is already registered', () => {
88 | const storeName = 'already-exists';
89 | let store;
90 | let existsSpy;
91 |
92 | beforeEach(() => {
93 | // ensure a success is returned and calls can be counted.
94 | existsSpy = jest
95 | .spyOn(ResourcesClient.prototype, 'declare')
96 | .mockImplementation((request, callback: any) => {
97 | const response = new ResourceDeclareResponse();
98 | callback(null, response);
99 | return null as any;
100 | });
101 |
102 | // register the resource for the first time
103 | store = kv(storeName);
104 | });
105 |
106 | afterEach(() => {
107 | jest.resetAllMocks();
108 | });
109 |
110 | describe('When registering a store with the same name', () => {
111 | let secondStore;
112 |
113 | beforeEach(() => {
114 | // make sure the initial registration isn't counted for these tests.
115 | existsSpy.mockClear();
116 | secondStore = kv(storeName);
117 | });
118 |
119 | it('Should not call the server again', () => {
120 | expect(existsSpy).not.toBeCalled();
121 | });
122 |
123 | it('Should return the same resource object', () => {
124 | expect(store === secondStore).toEqual(true);
125 | });
126 | });
127 |
128 | describe('When declaring usage', () => {
129 | it('Should return a store reference', () => {
130 | const ref = store.for('getting');
131 | expect(ref).toBeInstanceOf(StoreRef);
132 | });
133 | });
134 | });
135 | });
136 |
--------------------------------------------------------------------------------
/src/resources/oidc.ts:
--------------------------------------------------------------------------------
1 | // Copyright 2021, Nitric Technologies Pty Ltd.
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 | import {
15 | ResourceIdentifier,
16 | ResourceDeclareRequest,
17 | ResourceDeclareResponse,
18 | ResourceType,
19 | ResourceTypeMap,
20 | ApiSecurityDefinitionResource,
21 | ApiOpenIdConnectionDefinition,
22 | } from '@nitric/proto/resources/v1/resources_pb';
23 | import resourceClient from './client';
24 | import { make, newer, Resource } from './common';
25 | import { fromGrpcError } from '../api/errors';
26 |
27 | /**
28 | * Cloud storage bucket resource for large file storage.
29 | */
30 | export class OidcSecurityDefinition extends Resource {
31 | private apiName: string;
32 | private issuer: string;
33 | private ruleName: string;
34 | private audiences: string[];
35 |
36 | constructor(name: string, apiName: string, options: UnscopedOicdOptions) {
37 | super(name);
38 | this.apiName = apiName;
39 | this.issuer = options.issuer;
40 | this.audiences = options.audiences;
41 | this.ruleName = options.name;
42 | }
43 |
44 | protected resourceType(): ResourceTypeMap[keyof ResourceTypeMap] {
45 | return ResourceType.APISECURITYDEFINITION;
46 | }
47 |
48 | /**
49 | * Register this bucket as a required resource for the calling function/container.
50 | *
51 | * @returns a promise that resolves when the registration is complete
52 | */
53 | protected async register(): Promise {
54 | const req = new ResourceDeclareRequest();
55 | const resource = new ResourceIdentifier();
56 | resource.setName(this.ruleName);
57 | resource.setType(ResourceType.APISECURITYDEFINITION);
58 |
59 | const securityDefinition = new ApiSecurityDefinitionResource();
60 | const oidcDefinition = new ApiOpenIdConnectionDefinition();
61 |
62 | oidcDefinition.setAudiencesList(this.audiences);
63 | oidcDefinition.setIssuer(this.issuer);
64 |
65 | securityDefinition.setApiName(this.apiName);
66 | securityDefinition.setOidc(oidcDefinition);
67 |
68 | req.setId(resource);
69 | req.setApiSecurityDefinition(securityDefinition);
70 |
71 | return new Promise((resolve, reject) => {
72 | resourceClient.declare(req, (error, _: ResourceDeclareResponse) => {
73 | if (error) {
74 | reject(fromGrpcError(error));
75 | } else {
76 | resolve(resource);
77 | }
78 | });
79 | });
80 | }
81 | }
82 |
83 | export interface OidcOptions {
84 | name: string;
85 | issuer: string;
86 | audiences: string[];
87 | scopes: string[];
88 | }
89 |
90 | export type UnscopedOicdOptions = Omit;
91 |
92 | export type SecurityOption = (...scopes: string[]) => OidcOptions;
93 |
94 | /**
95 | * Constructs a new OpenID Connect (OIDC) security definition, which can be applied to APIs and their routes.
96 | *
97 | * This rule can be applied with various scopes, which are used to restrict access to the API.
98 | * @param options - The options for the OIDC security definition.
99 | *
100 | * @param options.name - The name of the OIDC security definition.
101 | * @param options.issuer - The OIDC issuer URL.
102 | * @param options.audiences - The OIDC audiences.
103 | * @returns SecurityOption
104 | */
105 | export const oidcRule = ({
106 | name,
107 | issuer,
108 | audiences,
109 | }: UnscopedOicdOptions): SecurityOption => {
110 | return (...scopes: string[]): OidcOptions => {
111 | return {
112 | name,
113 | issuer,
114 | audiences,
115 | scopes,
116 | };
117 | };
118 | };
119 |
120 | const baseMaker = make(OidcSecurityDefinition);
121 |
122 | /**
123 | *
124 | * @param apiName - The name of the API to attach the OIDC security definition to.
125 | * @param options - The options for the OIDC security definition.
126 | *
127 | * @returns factory function for creating a new OIDC security definition
128 | */
129 | export const attachOidc: newer = (
130 | apiName: string,
131 | options: UnscopedOicdOptions
132 | ) => {
133 | return baseMaker(`${options.name}-${apiName}`, apiName, options);
134 | };
135 |
--------------------------------------------------------------------------------
/src/resources/queue.test.ts:
--------------------------------------------------------------------------------
1 | // Copyright 2021, Nitric Technologies Pty Ltd.
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | import { ResourcesClient } from '@nitric/proto/resources/v1/resources_grpc_pb';
16 | import { UnimplementedError } from '../api/errors';
17 | import { Queue } from '../api';
18 | import { queue, QueueResource } from '.';
19 | import { ResourceDeclareResponse } from '@nitric/proto/resources/v1/resources_pb';
20 | import { status } from '@grpc/grpc-js';
21 |
22 | describe('Registering queue resources', () => {
23 | describe('Given declare returns an error from the resource server', () => {
24 | const MOCK_ERROR = {
25 | code: status.UNIMPLEMENTED,
26 | message: 'UNIMPLEMENTED',
27 | };
28 |
29 | const validName = 'my-queue';
30 | let declareSpy;
31 |
32 | beforeAll(() => {
33 | jest.spyOn(console, 'error').mockImplementation(() => {});
34 | declareSpy = jest
35 | .spyOn(ResourcesClient.prototype, 'declare')
36 | .mockImplementationOnce((request, callback: any) => {
37 | callback(MOCK_ERROR, null);
38 |
39 | return null as any;
40 | });
41 | });
42 |
43 | afterAll(() => {
44 | jest.restoreAllMocks();
45 | });
46 |
47 | it('Should throw the error', async () => {
48 | await expect(queue(validName)['registerPromise']).rejects.toBeInstanceOf(
49 | UnimplementedError
50 | );
51 | });
52 |
53 | it('Should call the resource server', () => {
54 | expect(declareSpy).toBeCalledTimes(1);
55 | });
56 | });
57 |
58 | describe('Given declare succeeds on the resource server', () => {
59 | describe('When the service succeeds', () => {
60 | const validName = 'my-queue2';
61 | let otherSpy;
62 |
63 | beforeAll(() => {
64 | otherSpy = jest
65 | .spyOn(ResourcesClient.prototype, 'declare')
66 | .mockImplementationOnce((request, callback: any) => {
67 | const response = new ResourceDeclareResponse();
68 | callback(null, response);
69 | return null as any;
70 | });
71 | });
72 |
73 | afterAll(() => {
74 | jest.resetAllMocks();
75 | });
76 |
77 | it('Should succeed', async () => {
78 | await expect(
79 | queue(validName)['registerPromise']
80 | ).resolves.not.toBeNull();
81 | });
82 |
83 | it('Should call the resource server', () => {
84 | expect(otherSpy).toBeCalledTimes(1);
85 | });
86 | });
87 | });
88 |
89 | describe('Given a topic is already registered', () => {
90 | const queueName = 'already-exists';
91 | let queueResource: QueueResource;
92 | let existsSpy;
93 |
94 | beforeEach(() => {
95 | // ensure a success is returned and calls can be counted.
96 | existsSpy = jest
97 | .spyOn(ResourcesClient.prototype, 'declare')
98 | .mockImplementation((request, callback: any) => {
99 | const response = new ResourceDeclareResponse();
100 | callback(null, response);
101 | return null as any;
102 | });
103 |
104 | // register the resource for the first time
105 | queueResource = queue(queueName);
106 | });
107 |
108 | afterEach(() => {
109 | jest.resetAllMocks();
110 | });
111 |
112 | describe('When registering a queue with the same name', () => {
113 | let secondTopic;
114 |
115 | beforeEach(() => {
116 | // make sure the initial registration isn't counted for these tests.
117 | existsSpy.mockClear();
118 | secondTopic = queue(queueName);
119 | });
120 |
121 | it('Should not call the server again', () => {
122 | expect(existsSpy).not.toBeCalled();
123 | });
124 |
125 | it('Should return the same resource object', () => {
126 | expect(queueResource === secondTopic).toEqual(true);
127 | });
128 | });
129 |
130 | describe('When declaring usage', () => {
131 | it('Should return a topic reference', () => {
132 | const ref = queueResource.for('dequeue');
133 | expect(ref).toBeInstanceOf(Queue);
134 | });
135 | });
136 | });
137 | });
138 |
--------------------------------------------------------------------------------
/src/resources/queue.ts:
--------------------------------------------------------------------------------
1 | // Copyright 2021, Nitric Technologies Pty Ltd.
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 | import { Queue, queues } from '@nitric/sdk/api/queues';
15 | import {
16 | ResourceIdentifier,
17 | ResourceDeclareRequest,
18 | ResourceDeclareResponse,
19 | ResourceType,
20 | Action,
21 | QueueResource as NitricQueueResource,
22 | ResourceTypeMap,
23 | } from '@nitric/proto/resources/v1/resources_pb';
24 | import resourceClient from './client';
25 | import { fromGrpcError } from '../api/errors';
26 | import { ActionsList, make, SecureResource } from './common';
27 |
28 | export type QueuePermission = 'enqueue' | 'dequeue';
29 |
30 | const everything: QueuePermission[] = ['enqueue', 'dequeue'];
31 |
32 | /**
33 | * Queue resource for async messaging
34 | */
35 | export class QueueResource<
36 | T extends Record = Record
37 | > extends SecureResource {
38 | /**
39 | * Register this queue as a required resource for the calling service/container.
40 | *
41 | * @returns a promise that resolves when the registration is complete
42 | */
43 | protected async register(): Promise {
44 | const req = new ResourceDeclareRequest();
45 | const resource = new ResourceIdentifier();
46 | resource.setName(this.name);
47 | resource.setType(ResourceType.QUEUE);
48 | req.setId(resource);
49 | req.setQueue(new NitricQueueResource());
50 |
51 | return new Promise((resolve, reject) => {
52 | resourceClient.declare(req, (error) => {
53 | if (error) {
54 | reject(fromGrpcError(error));
55 | } else {
56 | resolve(resource);
57 | }
58 | });
59 | });
60 | }
61 |
62 | protected permsToActions(...perms: QueuePermission[]): ActionsList {
63 | const actions: ActionsList = perms.reduce((actions, p) => {
64 | switch (p) {
65 | case 'enqueue':
66 | return [...actions, Action.QUEUEENQUEUE];
67 | case 'dequeue':
68 | return [...actions, Action.QUEUEDEQUEUE];
69 | default:
70 | throw new Error(
71 | `unknown permission ${p}, supported permissions are ${everything.join(
72 | ', '
73 | )}`
74 | );
75 | }
76 | }, []);
77 |
78 | return actions;
79 | }
80 |
81 | protected resourceType(): ResourceTypeMap[keyof ResourceTypeMap] {
82 | return ResourceType.QUEUE;
83 | }
84 |
85 | protected unwrapDetails(_: ResourceDeclareResponse): never {
86 | throw new Error('details unimplemented for queue');
87 | }
88 |
89 | /**
90 | * Return a queue reference and registers the permissions required by the currently scoped function for this resource.
91 | *
92 | * e.g. const taskQueue = resources.queue('work').for('enqueue')
93 | *
94 | * @deprecated use allow instead
95 | * @param perm - the access that the currently scoped function is requesting to this resource.
96 | * @param perms - the access that the currently scoped function is requesting to this resource.
97 | * @returns a useable queue.
98 | */
99 | public for(perm: QueuePermission, ...perms: QueuePermission[]): Queue
4 |
5 | 
17 |
18 |
19 | 
20 |
21 | 