@appsemble/cli 0.27.12 → 0.28.0

package/lib/resource.test.js

@@ -0,0 +1,391 @@
+import { resolveFixture } from '@appsemble/node-utils';
+import { createServer, createTestUser, models, setArgv, useTestDatabase } from '@appsemble/server';
+import { setTestApp } from 'axios-test-instance';
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { initAxios } from './initAxios.js';
+import { publishResource, updateResource } from './resource.js';
+import { authorizeCLI } from './testUtils.js';
+const { App, Organization, OrganizationMember, Resource } = models;
+const argv = { host: 'http://localhost', secret: 'test', aesSecret: 'testSecret' };
+let user;
+let organization;
+let testApp;
+useTestDatabase(import.meta);
+beforeAll(() => {
+    vi.useFakeTimers();
+    setArgv(argv);
+});
+beforeEach(async () => {
+    vi.clearAllTimers();
+    vi.setSystemTime(0);
+    const server = await createServer();
+    testApp = await setTestApp(server);
+    initAxios({ remote: testApp.defaults.baseURL });
+    user = await createTestUser();
+    organization = await Organization.create({
+        id: 'testorganization',
+        name: 'Test Organization',
+    });
+    await OrganizationMember.create({
+        OrganizationId: organization.id,
+        UserId: user.id,
+        role: 'Owner',
+    });
+    await Organization.create({ id: 'appsemble', name: 'Appsemble' });
+});
+afterAll(() => {
+    vi.useRealTimers();
+});
+describe('publishResource', () => {
+    it('should publish resources from a file', async () => {
+        const resourceDefinition = {
+            roles: ['$public'],
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['name'],
+                properties: {
+                    name: {
+                        type: 'string',
+                    },
+                    email: {
+                        type: 'string',
+                        format: 'email',
+                    },
+                },
+            },
+        };
+        const app = await App.create({
+            path: 'test-app',
+            definition: {
+                resources: { test: resourceDefinition },
+                name: 'Test App',
+                defaultPage: 'Test Page',
+            },
+            vapidPublicKey: 'a',
+            vapidPrivateKey: 'b',
+            visibility: 'public',
+            OrganizationId: organization.id,
+        });
+        await authorizeCLI('resources:write', testApp);
+        await publishResource({
+            appId: app.id,
+            definition: resourceDefinition,
+            path: resolveFixture('resources/test.json'),
+            remote: testApp.defaults.baseURL,
+            type: 'test',
+            seed: false,
+        });
+        const resources = await Resource.findAll({
+            where: { AppId: app.id },
+        });
+        expect(resources.map((r) => r.toJSON())).toMatchInlineSnapshot(`
+      [
+        {
+          "$created": "1970-01-01T00:00:00.000Z",
+          "$updated": "1970-01-01T00:00:00.000Z",
+          "email": "test@example.com",
+          "id": 1,
+          "name": "John Doe",
+        },
+        {
+          "$created": "1970-01-01T00:00:00.000Z",
+          "$updated": "1970-01-01T00:00:00.000Z",
+          "email": "test2@example.com",
+          "id": 2,
+          "name": "Jane Doe",
+        },
+        {
+          "$created": "1970-01-01T00:00:00.000Z",
+          "$updated": "1970-01-01T00:00:00.000Z",
+          "id": 3,
+          "name": "test name",
+        },
+      ]
+    `);
+    });
+});
+it('should throw  if there is an error', async () => {
+    const resourceDefinition = {
+        roles: ['$public'],
+        schema: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['name'],
+            properties: {
+                name: {
+                    type: 'string',
+                },
+                email: {
+                    type: 'string',
+                    format: 'email',
+                },
+            },
+        },
+    };
+    const app = await App.create({
+        path: 'test-app',
+        definition: {
+            resources: { test: resourceDefinition },
+            name: 'Test App',
+            defaultPage: 'Test Page',
+        },
+        vapidPublicKey: 'a',
+        vapidPrivateKey: 'b',
+        visibility: 'public',
+        OrganizationId: organization.id,
+    });
+    await authorizeCLI('resources:write', testApp);
+    await app.destroy();
+    await expect(() => publishResource({
+        appId: app.id,
+        definition: resourceDefinition,
+        path: resolveFixture('resources/test.json'),
+        remote: testApp.defaults.baseURL,
+        type: 'test',
+        seed: false,
+    })).rejects.toThrow('Request failed with status code 404');
+});
+describe('updateResource', () => {
+    it('should update existing resources', async () => {
+        const resourceDefinition = {
+            roles: ['$public'],
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['name'],
+                properties: {
+                    name: {
+                        type: 'string',
+                    },
+                    email: {
+                        type: 'string',
+                        format: 'email',
+                    },
+                },
+            },
+        };
+        const app = await App.create({
+            path: 'test-app',
+            definition: {
+                resources: { test: resourceDefinition },
+                name: 'Test App',
+                defaultPage: 'Test Page',
+            },
+            vapidPublicKey: 'a',
+            vapidPrivateKey: 'b',
+            visibility: 'public',
+            OrganizationId: organization.id,
+        });
+        await Resource.bulkCreate([
+            {
+                id: 1,
+                type: 'test',
+                AppId: app.id,
+                data: {
+                    name: 'Hello World',
+                },
+            },
+            {
+                id: 2,
+                type: 'test',
+                AppId: app.id,
+                data: {
+                    name: 'World Hello',
+                    email: 'hello@example.com',
+                },
+            },
+            {
+                id: 3,
+                type: 'test',
+                AppId: app.id,
+                data: {
+                    name: 'Random name',
+                    email: 'removed@example.com',
+                },
+            },
+        ]);
+        await authorizeCLI('resources:write', testApp);
+        await updateResource({
+            appId: app.id,
+            resourceName: 'test',
+            remote: testApp.defaults.baseURL,
+            path: resolveFixture('resources/test-update.json'),
+        });
+        const resources = await Resource.findAll();
+        expect(resources.map((r) => r.toJSON())).toMatchInlineSnapshot(`
+      [
+        {
+          "$created": "1970-01-01T00:00:00.000Z",
+          "$updated": "1970-01-01T00:00:00.000Z",
+          "email": "test@example.com",
+          "id": 1,
+          "name": "John Doe",
+        },
+        {
+          "$created": "1970-01-01T00:00:00.000Z",
+          "$updated": "1970-01-01T00:00:00.000Z",
+          "email": "test2@example.com",
+          "id": 2,
+          "name": "Jane Doe",
+        },
+        {
+          "$created": "1970-01-01T00:00:00.000Z",
+          "$updated": "1970-01-01T00:00:00.000Z",
+          "id": 3,
+          "name": "test name",
+        },
+      ]
+    `);
+    });
+    it('should throw if the resource to be updated does not exist', async () => {
+        const resourceDefinition = {
+            roles: ['$public'],
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['name'],
+                properties: {
+                    name: {
+                        type: 'string',
+                    },
+                    email: {
+                        type: 'string',
+                        format: 'email',
+                    },
+                },
+            },
+        };
+        const app = await App.create({
+            path: 'test-app',
+            definition: {
+                resources: { test: resourceDefinition },
+                name: 'Test App',
+                defaultPage: 'Test Page',
+            },
+            vapidPublicKey: 'a',
+            vapidPrivateKey: 'b',
+            visibility: 'public',
+            OrganizationId: organization.id,
+        });
+        await Resource.bulkCreate([
+            {
+                id: 1,
+                type: 'test',
+                AppId: app.id,
+                data: {
+                    name: 'Hello World',
+                },
+            },
+            {
+                id: 2,
+                type: 'test',
+                AppId: app.id,
+                data: {
+                    name: 'World Hello',
+                    email: 'hello@example.com',
+                },
+            },
+        ]);
+        await authorizeCLI('resources:write', testApp);
+        await expect(() => updateResource({
+            appId: app.id,
+            resourceName: 'test',
+            remote: testApp.defaults.baseURL,
+            path: resolveFixture('resources/test-update.json'),
+        })).rejects.toThrow('Request failed with status code 404');
+    });
+    it('should not update if there are no IDs in resource file', async () => {
+        const resourceDefinition = {
+            roles: ['$public'],
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['name'],
+                properties: {
+                    name: {
+                        type: 'string',
+                    },
+                    email: {
+                        type: 'string',
+                        format: 'email',
+                    },
+                },
+            },
+        };
+        const app = await App.create({
+            path: 'test-app',
+            definition: {
+                resources: { test: resourceDefinition },
+                name: 'Test App',
+                defaultPage: 'Test Page',
+            },
+            vapidPublicKey: 'a',
+            vapidPrivateKey: 'b',
+            visibility: 'public',
+            OrganizationId: organization.id,
+        });
+        await Resource.bulkCreate([
+            {
+                id: 1,
+                type: 'test',
+                AppId: app.id,
+                data: {
+                    name: 'Hello World',
+                },
+            },
+            {
+                id: 2,
+                type: 'test',
+                AppId: app.id,
+                data: {
+                    name: 'World Hello',
+                    email: 'hello@example.com',
+                },
+            },
+        ]);
+        await authorizeCLI('resources:write', testApp);
+        const resources = await Resource.findAll();
+        expect(resources.map((r) => r.toJSON())).toMatchInlineSnapshot(`
+      [
+        {
+          "$created": "1970-01-01T00:00:00.000Z",
+          "$updated": "1970-01-01T00:00:00.000Z",
+          "id": 1,
+          "name": "Hello World",
+        },
+        {
+          "$created": "1970-01-01T00:00:00.000Z",
+          "$updated": "1970-01-01T00:00:00.000Z",
+          "email": "hello@example.com",
+          "id": 2,
+          "name": "World Hello",
+        },
+      ]
+    `);
+        await updateResource({
+            appId: app.id,
+            resourceName: 'test',
+            remote: testApp.defaults.baseURL,
+            path: resolveFixture('resources/test.json'),
+        });
+        expect(resources.map((r) => r.toJSON())).toMatchInlineSnapshot(`
+      [
+        {
+          "$created": "1970-01-01T00:00:00.000Z",
+          "$updated": "1970-01-01T00:00:00.000Z",
+          "id": 1,
+          "name": "Hello World",
+        },
+        {
+          "$created": "1970-01-01T00:00:00.000Z",
+          "$updated": "1970-01-01T00:00:00.000Z",
+          "email": "hello@example.com",
+          "id": 2,
+          "name": "World Hello",
+        },
+      ]
+    `);
+    });
+});
+//# sourceMappingURL=resource.test.js.map

package/lib/team.d.ts

@@ -8,6 +8,10 @@ interface SharedTeamParams {
      * The remote server to create the team on.
      */
     remote: string;
+    /**
+     * The client credentials used to authenticate
+     */
+    clientCredentials?: string;
 }
 interface SharedExistingTeamParams extends SharedTeamParams {
     /**
@@ -48,8 +52,8 @@ interface CreateTeamParams extends SharedTeamParams {
     annotations?: string[];
 }
 export declare function resolveAnnotations(annotations: string[]): Record<string, string>;
-export declare function createTeam({ annotations, appId, name, remote, }: CreateTeamParams): Promise<void>;
-export declare function deleteTeam({ appId, id, remote }: SharedExistingTeamParams): Promise<void>;
+export declare function createTeam({ annotations, appId, clientCredentials, name, remote, }: CreateTeamParams): Promise<void>;
+export declare function deleteTeam({ appId, clientCredentials, id, remote, }: SharedExistingTeamParams): Promise<void>;
 export declare function updateTeam({ annotations, appId, id, name, remote, }: UpdateTeamParams): Promise<void>;
 export declare function inviteMember({ appId, id, remote, user, }: SharedTeamMemberParams): Promise<void>;
 export declare function updateMember({ appId, id, remote, role, user, }: UpdateTeamMemberParams): Promise<void>;

package/lib/team.js

@@ -1,4 +1,4 @@
-import { AppsembleError, logger } from '@appsemble/node-utils';
+import { AppsembleError, authenticate, logger } from '@appsemble/node-utils';
 import axios from 'axios';
 export function resolveAnnotations(annotations) {
     const annotationRegex = /^\w+=.+$/;
@@ -12,22 +12,24 @@ export function resolveAnnotations(annotations) {
         }))
         : undefined;
 }
-export async function createTeam({ annotations = [], appId, name, remote, }) {
+export async function createTeam({ annotations = [], appId, clientCredentials, name, remote, }) {
     logger.info(`Creating team ${name}`);
+    await authenticate(remote, 'teams:write', clientCredentials);
     const { data: { id }, } = await axios.post(`/api/apps/${appId}/teams`, {
         name,
         annotations: resolveAnnotations(annotations),
     }, { baseURL: remote });
     logger.info(`Successfully created team ${name} with ID ${id}`);
 }
-export async function deleteTeam({ appId, id, remote }) {
+export async function deleteTeam({ appId, clientCredentials, id, remote, }) {
+    await authenticate(remote, 'teams:write', clientCredentials);
     logger.info(`Deleting team ${id}`);
     await axios.delete(`/api/apps/${appId}/teams/${id}`, { baseURL: remote });
     logger.info(`Successfully deleted team ${id}`);
 }
 export async function updateTeam({ annotations = [], appId, id, name, remote, }) {
     logger.info(`Updating team ${id}`);
-    await axios.put(`/api/apps/${appId}/teams/${id}`, {
+    await axios.patch(`/api/apps/${appId}/teams/${id}`, {
         name,
         annotations: resolveAnnotations(annotations),
     }, { baseURL: remote });

package/lib/team.test.d.ts

@@ -0,0 +1 @@
+export {};