@appsemble/cli 0.29.11 → 0.30.2

package/lib/config.test.js

@@ -5,232 +5,234 @@ import { AppsembleError, resolveFixture } from '@appsemble/node-utils';
 import { ts } from 'ts-json-schema-generator';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { getProjectImplementations } from './config.js';
-beforeEach(() => {
-    vi.spyOn(process, 'cwd').mockReturnValue(resolveFixture('.'));
-});
-describe('getProjectImplementations', () => {
-    it('should extract configuration from a TypeScript project', () => {
-        const result = getProjectImplementations({
-            name: '',
-            layout: 'float',
-            version: '1.33.7',
-            webpack: '',
-            output: '',
-            dir: resolveFixture('getProjectImplementations/valid'),
-        });
-        expect(result).toStrictEqual({
-            actions: { testAction: { description: undefined } },
-            events: {
-                emit: { testEmit: { description: undefined } },
-                listen: { testListener: { description: undefined } },
-            },
-            messages: undefined,
-            parameters: {
-                $schema: 'http://json-schema.org/draft-07/schema#',
-                additionalProperties: false,
-                properties: {
-                    param1: { type: 'string' },
-                    param2: { type: 'number' },
-                    param3: { type: 'boolean' },
-                    param4: { type: 'string' },
-                    param5: {
-                        additionalProperties: false,
-                        properties: {
-                            nested1: { type: 'string' },
-                            nested2: { type: 'number' },
-                            nested3: { type: 'boolean' },
+describe('config', () => {
+    beforeEach(() => {
+        vi.spyOn(process, 'cwd').mockReturnValue(resolveFixture('.'));
+    });
+    describe('getProjectImplementations', () => {
+        it('should extract configuration from a TypeScript project', () => {
+            const result = getProjectImplementations({
+                name: '',
+                layout: 'float',
+                version: '1.33.7',
+                webpack: '',
+                output: '',
+                dir: resolveFixture('getProjectImplementations/valid'),
+            });
+            expect(result).toStrictEqual({
+                actions: { testAction: { description: undefined } },
+                events: {
+                    emit: { testEmit: { description: undefined } },
+                    listen: { testListener: { description: undefined } },
+                },
+                messages: undefined,
+                parameters: {
+                    $schema: 'http://json-schema.org/draft-07/schema#',
+                    additionalProperties: false,
+                    properties: {
+                        param1: { type: 'string' },
+                        param2: { type: 'number' },
+                        param3: { type: 'boolean' },
+                        param4: { type: 'string' },
+                        param5: {
+                            additionalProperties: false,
+                            properties: {
+                                nested1: { type: 'string' },
+                                nested2: { type: 'number' },
+                                nested3: { type: 'boolean' },
+                            },
+                            required: ['nested1', 'nested2', 'nested3'],
+                            type: 'object',
                         },
-                        required: ['nested1', 'nested2', 'nested3'],
-                        type: 'object',
+                        param6: { items: { type: 'string' }, type: 'array' },
                     },
-                    param6: { items: { type: 'string' }, type: 'array' },
+                    required: ['param1', 'param2', 'param3', 'param5', 'param6'],
+                    type: 'object',
                 },
-                required: ['param1', 'param2', 'param3', 'param5', 'param6'],
-                type: 'object',
-            },
+            });
         });
-    });
-    // Spying on TypeScript functions no longer works.
-    // eslint-disable-next-line vitest/no-disabled-tests
-    it.skip('should not use TypeScript if all metadata is present in the original config', () => {
-        vi.spyOn(ts, 'createProgram');
-        const input = {
-            actions: {},
-            events: { emit: { foo: {} }, listen: { bar: {} } },
-            layout: 'float',
-            parameters: { type: 'object' },
-            version: '1.33.7',
-            webpack: '',
-            output: '',
-            dir: resolveFixture('getProjectImplementations/valid'),
-            name: '',
-        };
-        const result = getProjectImplementations(input);
-        expect(result).toBe(input);
-        expect(ts.createProgram).not.toHaveBeenCalled();
-    });
-    it('should prefer actions overrides over TypeScript actions', () => {
-        const result = getProjectImplementations({
-            actions: {},
-            version: '1.33.7',
-            webpack: '',
-            output: '',
-            dir: resolveFixture('getProjectImplementations/valid'),
-            name: '',
+        // Spying on TypeScript functions no longer works.
+        // eslint-disable-next-line vitest/no-disabled-tests
+        it.skip('should not use TypeScript if all metadata is present in the original config', () => {
+            vi.spyOn(ts, 'createProgram');
+            const input = {
+                actions: {},
+                events: { emit: { foo: {} }, listen: { bar: {} } },
+                layout: 'float',
+                parameters: { type: 'object' },
+                version: '1.33.7',
+                webpack: '',
+                output: '',
+                dir: resolveFixture('getProjectImplementations/valid'),
+                name: '',
+            };
+            const result = getProjectImplementations(input);
+            expect(result).toBe(input);
+            expect(ts.createProgram).not.toHaveBeenCalled();
         });
-        expect(result.actions).toStrictEqual({});
-    });
-    it('should prefer events overrides over TypeScript events', () => {
-        const result = getProjectImplementations({
-            events: { emit: { onSuccess: {} } },
-            version: '1.33.7',
-            webpack: '',
-            output: '',
-            dir: resolveFixture('getProjectImplementations/valid'),
-            name: '',
+        it('should prefer actions overrides over TypeScript actions', () => {
+            const result = getProjectImplementations({
+                actions: {},
+                version: '1.33.7',
+                webpack: '',
+                output: '',
+                dir: resolveFixture('getProjectImplementations/valid'),
+                name: '',
+            });
+            expect(result.actions).toStrictEqual({});
         });
-        expect(result.events).toStrictEqual({ emit: { onSuccess: {} } });
-    });
-    it('should prefer parameters overrides over TypeScript parameters', () => {
-        const result = getProjectImplementations({
-            parameters: { type: 'object' },
-            version: '1.33.7',
-            webpack: '',
-            output: '',
-            dir: resolveFixture('getProjectImplementations/valid'),
-            name: '',
+        it('should prefer events overrides over TypeScript events', () => {
+            const result = getProjectImplementations({
+                events: { emit: { onSuccess: {} } },
+                version: '1.33.7',
+                webpack: '',
+                output: '',
+                dir: resolveFixture('getProjectImplementations/valid'),
+                name: '',
+            });
+            expect(result.events).toStrictEqual({ emit: { onSuccess: {} } });
         });
-        expect(result.parameters).toStrictEqual({ type: 'object' });
-    });
-    it('should throw if duplicate Actions are found', () => {
-        expect(() => getProjectImplementations({
-            webpack: '',
-            output: '',
-            dir: resolveFixture('getProjectImplementations/duplicateActions'),
-            name: '',
-            version: '1.33.7',
-        })).toThrow(new AppsembleError("Found duplicate interface 'Actions' in 'getProjectImplementations/duplicateActions/index.ts:31'"));
-    });
-    it('should throw if duplicate EventEmitters are found', () => {
-        expect(() => getProjectImplementations({
-            webpack: '',
-            output: '',
-            dir: resolveFixture('getProjectImplementations/duplicateEventEmitters'),
-            name: '',
-            version: '1.33.7',
-        })).toThrow(new AppsembleError("Found duplicate interface 'EventEmitters' in 'getProjectImplementations/duplicateEventEmitters/index.ts:31'"));
-    });
-    it('should throw if duplicate EventListeners are found', () => {
-        expect(() => getProjectImplementations({
-            webpack: '',
-            output: '',
-            dir: resolveFixture('getProjectImplementations/duplicateEventListeners'),
-            name: '',
-            version: '1.33.7',
-        })).toThrow(new AppsembleError("Found duplicate interface 'EventListeners' in 'getProjectImplementations/duplicateEventListeners/index.ts:31'"));
-    });
-    it('should throw if duplicate Parameters are found', () => {
-        expect(() => getProjectImplementations({
-            webpack: '',
-            output: '',
-            dir: resolveFixture('getProjectImplementations/duplicateParameters'),
-            name: '',
-            version: '1.33.7',
-        })).toThrow(new AppsembleError("Found duplicate interface 'Parameters' in 'getProjectImplementations/duplicateParameters/index.ts:31'"));
-    });
-    it('should handle fontawesome icons', () => {
-        const result = getProjectImplementations({
-            webpack: '',
-            output: '',
-            dir: resolveFixture('getProjectImplementations/fontawesomeParameters'),
-            name: '',
-            version: '1.33.7',
+        it('should prefer parameters overrides over TypeScript parameters', () => {
+            const result = getProjectImplementations({
+                parameters: { type: 'object' },
+                version: '1.33.7',
+                webpack: '',
+                output: '',
+                dir: resolveFixture('getProjectImplementations/valid'),
+                name: '',
+            });
+            expect(result.parameters).toStrictEqual({ type: 'object' });
+        });
+        it('should throw if duplicate Actions are found', () => {
+            expect(() => getProjectImplementations({
+                webpack: '',
+                output: '',
+                dir: resolveFixture('getProjectImplementations/duplicateActions'),
+                name: '',
+                version: '1.33.7',
+            })).toThrow(new AppsembleError("Found duplicate interface 'Actions' in 'getProjectImplementations/duplicateActions/index.ts:31'"));
+        });
+        it('should throw if duplicate EventEmitters are found', () => {
+            expect(() => getProjectImplementations({
+                webpack: '',
+                output: '',
+                dir: resolveFixture('getProjectImplementations/duplicateEventEmitters'),
+                name: '',
+                version: '1.33.7',
+            })).toThrow(new AppsembleError("Found duplicate interface 'EventEmitters' in 'getProjectImplementations/duplicateEventEmitters/index.ts:31'"));
         });
-        expect(result).toStrictEqual({
-            actions: undefined,
-            events: undefined,
-            messages: undefined,
-            parameters: {
-                $schema: 'http://json-schema.org/draft-07/schema#',
-                additionalProperties: false,
-                properties: {
-                    icon: { description: 'This is an icon.', format: 'fontawesome', type: 'string' },
+        it('should throw if duplicate EventListeners are found', () => {
+            expect(() => getProjectImplementations({
+                webpack: '',
+                output: '',
+                dir: resolveFixture('getProjectImplementations/duplicateEventListeners'),
+                name: '',
+                version: '1.33.7',
+            })).toThrow(new AppsembleError("Found duplicate interface 'EventListeners' in 'getProjectImplementations/duplicateEventListeners/index.ts:31'"));
+        });
+        it('should throw if duplicate Parameters are found', () => {
+            expect(() => getProjectImplementations({
+                webpack: '',
+                output: '',
+                dir: resolveFixture('getProjectImplementations/duplicateParameters'),
+                name: '',
+                version: '1.33.7',
+            })).toThrow(new AppsembleError("Found duplicate interface 'Parameters' in 'getProjectImplementations/duplicateParameters/index.ts:31'"));
+        });
+        it('should handle fontawesome icons', () => {
+            const result = getProjectImplementations({
+                webpack: '',
+                output: '',
+                dir: resolveFixture('getProjectImplementations/fontawesomeParameters'),
+                name: '',
+                version: '1.33.7',
+            });
+            expect(result).toStrictEqual({
+                actions: undefined,
+                events: undefined,
+                messages: undefined,
+                parameters: {
+                    $schema: 'http://json-schema.org/draft-07/schema#',
+                    additionalProperties: false,
+                    properties: {
+                        icon: { description: 'This is an icon.', format: 'fontawesome', type: 'string' },
+                    },
+                    type: 'object',
                 },
-                type: 'object',
-            },
+            });
         });
-    });
-    it('should handle TypeScript pre emit diagnostics', () => {
-        function fn() {
-            getProjectImplementations({
+        it('should handle TypeScript pre emit diagnostics', () => {
+            function fn() {
+                getProjectImplementations({
+                    name: '',
+                    layout: 'float',
+                    version: '1.33.7',
+                    webpack: '',
+                    output: '',
+                    dir: resolveFixture('getProjectImplementations/tsError'),
+                });
+            }
+            expect(fn).toThrow(AppsembleError);
+            expect(fn).toThrow(/'unused' is declared but its value is never read/);
+        });
+        it('should extract comments', () => {
+            const result = getProjectImplementations({
                 name: '',
                 layout: 'float',
                 version: '1.33.7',
                 webpack: '',
                 output: '',
-                dir: resolveFixture('getProjectImplementations/tsError'),
+                dir: resolveFixture('getProjectImplementations/comments'),
             });
-        }
-        expect(fn).toThrow(AppsembleError);
-        expect(fn).toThrow(/'unused' is declared but its value is never read/);
-    });
-    it('should extract comments', () => {
-        const result = getProjectImplementations({
-            name: '',
-            layout: 'float',
-            version: '1.33.7',
-            webpack: '',
-            output: '',
-            dir: resolveFixture('getProjectImplementations/comments'),
-        });
-        expect(result).toStrictEqual({
-            actions: {
-                comment: {
-                    description: 'Valid action comment',
-                },
-                duplicate: {
-                    description: 'Expected comment',
-                },
-                line: {
-                    description: undefined,
-                },
-            },
-            events: {
-                emit: {
-                    testEmit: {
-                        description: 'Test event emitter.',
+            expect(result).toStrictEqual({
+                actions: {
+                    comment: {
+                        description: 'Valid action comment',
+                    },
+                    duplicate: {
+                        description: 'Expected comment',
+                    },
+                    line: {
+                        description: undefined,
                     },
                 },
-                listen: {
-                    testListener: {
-                        description: 'Test event listener.',
+                events: {
+                    emit: {
+                        testEmit: {
+                            description: 'Test event emitter.',
+                        },
+                    },
+                    listen: {
+                        testListener: {
+                            description: 'Test event listener.',
+                        },
                     },
                 },
-            },
-            messages: undefined,
-            parameters: {
-                $schema: 'http://json-schema.org/draft-07/schema#',
-                additionalProperties: false,
-                properties: {
-                    param: {},
+                messages: undefined,
+                parameters: {
+                    $schema: 'http://json-schema.org/draft-07/schema#',
+                    additionalProperties: false,
+                    properties: {
+                        param: {},
+                    },
+                    required: ['param'],
+                    type: 'object',
                 },
-                required: ['param'],
-                type: 'object',
-            },
+            });
         });
-    });
-    describe('official blocks', () => {
-        const blocksDir = new URL('../../../blocks/', import.meta.url);
-        it.each(readdirSync(blocksDir))('%s', (name) => {
-            const dir = fileURLToPath(new URL(name, blocksDir));
-            const result = getProjectImplementations({
-                name,
-                version: '',
-                output: '',
-                webpack: undefined,
-                dir,
+        describe('official blocks', () => {
+            const blocksDir = new URL('../../../blocks/', import.meta.url);
+            it.each(readdirSync(blocksDir))('%s', (name) => {
+                const dir = fileURLToPath(new URL(name, blocksDir));
+                const result = getProjectImplementations({
+                    name,
+                    version: '',
+                    output: '',
+                    webpack: undefined,
+                    dir,
+                });
+                expect(result).toMatchSnapshot();
             });
-            expect(result).toMatchSnapshot();
         });
     });
 });

package/lib/createServers.js

@@ -36,7 +36,9 @@ export function createApiServer({ context }) {
         app.use(compress());
     }
     app.use(compose([
-        conditional((ctx) => ctx.path.startsWith('/api') || ctx.path === '/oauth2/token', cors()),
+        conditional((ctx) => ctx.path.startsWith('/api') ||
+            ctx.path === '/auth/oauth2/token' ||
+            /\/apps\/\d+\/auth\/oauth2\/token/.test(ctx.path), cors()),
         koas(api(version, argv), [
             parameters(),
             bodyParser(),

package/lib/group.d.ts

@@ -0,0 +1,61 @@
+import { type AppRole } from '@appsemble/types';
+interface SharedGroupParams {
+    /**
+     * The ID of the app to create the group for.
+     */
+    appId: number;
+    /**
+     * The remote server to create the group on.
+     */
+    remote: string;
+    /**
+     * The client credentials used to authenticate
+     */
+    clientCredentials?: string;
+}
+interface SharedExistingGroupParams extends SharedGroupParams {
+    /**
+     * The ID of the group.
+     */
+    id: number;
+}
+interface SharedGroupMemberParams extends SharedExistingGroupParams {
+    /**
+     * The ID or email address of the group member.
+     */
+    user: string;
+}
+interface UpdateGroupMemberParams extends SharedGroupMemberParams {
+    /**
+     * The new role of the group member.
+     */
+    role: AppRole;
+}
+interface UpdateGroupParams extends SharedExistingGroupParams {
+    /**
+     * The new name of the group.
+     */
+    name?: string;
+    /**
+     * The list of annotations to apply in key=value format.
+     */
+    annotations?: string[];
+}
+interface CreateGroupParams extends SharedGroupParams {
+    /**
+     * The name of the group.
+     */
+    name: string;
+    /**
+     * The list of annotations to apply in key=value format.
+     */
+    annotations?: string[];
+}
+export declare function resolveAnnotations(annotations: string[]): Record<string, string>;
+export declare function createGroup({ annotations, appId, clientCredentials, name, remote, }: CreateGroupParams): Promise<void>;
+export declare function deleteGroup({ clientCredentials, id, remote, }: SharedExistingGroupParams): Promise<void>;
+export declare function updateGroup({ annotations, id, name, remote, }: UpdateGroupParams): Promise<void>;
+export declare function inviteMember({ id, remote, user }: SharedGroupMemberParams): Promise<void>;
+export declare function updateMember({ id, remote, role, user, }: UpdateGroupMemberParams): Promise<void>;
+export declare function deleteMember({ id, user }: SharedGroupMemberParams): Promise<void>;
+export {};

package/lib/group.js

@@ -0,0 +1,55 @@
+import { AppsembleError, authenticate, logger } from '@appsemble/node-utils';
+import axios from 'axios';
+export function resolveAnnotations(annotations) {
+    const annotationRegex = /^\w+=.+$/;
+    if (annotations.some((a) => !annotationRegex.test(a))) {
+        throw new AppsembleError('One of the annotations did not follow the pattern of key=value');
+    }
+    return annotations.length
+        ? Object.fromEntries(annotations.map((annotation) => {
+            const [key, ...value] = annotation.split('=');
+            return [key, value.join('=')];
+        }))
+        : undefined;
+}
+export async function createGroup({ annotations = [], appId, clientCredentials, name, remote, }) {
+    logger.info(`Creating group ${name}`);
+    await authenticate(remote, 'groups:write', clientCredentials);
+    const { data: { id }, } = await axios.post(`/api/apps/${appId}/groups`, {
+        name,
+        annotations: resolveAnnotations(annotations),
+    }, { baseURL: remote });
+    logger.info(`Successfully created group ${name} with ID ${id}`);
+}
+export async function deleteGroup({ clientCredentials, id, remote, }) {
+    await authenticate(remote, 'groups:write', clientCredentials);
+    logger.info(`Deleting group ${id}`);
+    await axios.delete(`/api/groups/${id}`, { baseURL: remote });
+    logger.info(`Successfully deleted group ${id}`);
+}
+export async function updateGroup({ annotations = [], id, name, remote, }) {
+    logger.info(`Updating group ${id}`);
+    await axios.patch(`/api/groups/${id}`, {
+        name,
+        annotations: resolveAnnotations(annotations),
+    }, { baseURL: remote });
+    logger.info(`Successfully updated group ${id}`);
+}
+export async function inviteMember({ id, remote, user }) {
+    logger.info(`Inviting ${user} to group ${id}`);
+    await axios.post(`/api/groups/${id}/invites`, [{ email: user, role: 'Member' }], {
+        baseURL: remote,
+    });
+    logger.info(`Successfully invited ${user} to group ${id}`);
+}
+export async function updateMember({ id, remote, role, user, }) {
+    logger.info(`Updating ${user}’s role in group ${id} to ${role}`);
+    await axios.put(`/api/group-members/${user}/role`, { role }, { baseURL: remote });
+    logger.info(`Successfully updated ${user} in group ${id}`);
+}
+export async function deleteMember({ id, user }) {
+    logger.info(`Deleting ${user} to group ${id}`);
+    await axios.delete(`/api/group-members/${user}?selectedGroupId=${id}`);
+    logger.info(`Successfully deleted ${user} from group ${id}`);
+}
+//# sourceMappingURL=group.js.map