@appsemble/cli 0.29.10 → 0.30.1

package/lib/{team.test.js → group.test.js}

@@ -1,11 +1,11 @@
-import { createServer, createTestUser, models, setArgv, useTestDatabase } from '@appsemble/server';
-import { TeamRole } from '@appsemble/utils';
+import { createServer, createTestAppMember, createTestUser, models, setArgv, useTestDatabase, } from '@appsemble/server';
+import { PredefinedOrganizationRole } from '@appsemble/types';
 import { setTestApp } from 'axios-test-instance';
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { createGroup, deleteGroup, deleteMember, inviteMember, resolveAnnotations, updateGroup, updateMember, } from './group.js';
 import { initAxios } from './initAxios.js';
-import { createTeam, deleteMember, deleteTeam, inviteMember, resolveAnnotations, updateMember, updateTeam, } from './team.js';
 import { authorizeCLI } from './testUtils.js';
-const { App, AppMember, BlockVersion, Organization, OrganizationMember, Team, TeamMember } = models;
+const { App, AppMember, BlockVersion, Group, GroupInvite, GroupMember, Organization, OrganizationMember, } = models;
 const argv = { host: 'http://localhost', secret: 'test', aesSecret: 'testSecret' };
 let user;
 let organization;
@@ -29,7 +29,7 @@ beforeEach(async () => {
     await OrganizationMember.create({
         OrganizationId: organization.id,
         UserId: user.id,
-        role: 'Owner',
+        role: PredefinedOrganizationRole.Owner,
     });
     await Organization.create({ id: 'appsemble', name: 'Appsemble' });
     await BlockVersion.create({
@@ -49,14 +49,14 @@ beforeEach(async () => {
 afterAll(() => {
     vi.useRealTimers();
 });
-describe('createTeam', () => {
-    it('should create a new team', async () => {
+describe('createGroup', () => {
+    it('should create a new group', async () => {
         const app = await App.create({
             definition: {
                 name: 'Test App',
                 defaultPage: 'Test Page',
                 security: {
-                    teams: {
+                    groups: {
                         join: 'anyone',
                         invite: [],
                     },
@@ -74,19 +74,20 @@ describe('createTeam', () => {
             vapidPrivateKey: 'b',
             OrganizationId: organization.id,
         });
-        const clientCredentials = await authorizeCLI('teams:write', testApp);
-        await createTeam({
+        const clientCredentials = await authorizeCLI('groups:write', testApp);
+        await createGroup({
             appId: app.id,
             name: 'test',
             remote: testApp.defaults.baseURL,
             clientCredentials,
         });
-        const team = await Team.findOne();
-        expect(team).toMatchInlineSnapshot(`
+        const group = await Group.findOne();
+        expect(group).toMatchInlineSnapshot(`
       {
         "AppId": 1,
         "annotations": null,
         "created": 1970-01-01T00:00:00.000Z,
+        "demo": false,
         "id": 1,
         "name": "test",
         "updated": 1970-01-01T00:00:00.000Z,
@@ -94,8 +95,8 @@ describe('createTeam', () => {
     `);
     });
     it('should throw if app does not exist', async () => {
-        const clientCredentials = await authorizeCLI('teams:write', testApp);
-        await expect(() => createTeam({
+        const clientCredentials = await authorizeCLI('groups:write', testApp);
+        await expect(() => createGroup({
             appId: 1,
             name: 'test',
             remote: testApp.defaults.baseURL,
@@ -103,14 +104,14 @@ describe('createTeam', () => {
         })).rejects.toThrow('Request failed with status code 404');
     });
 });
-describe('deleteTeam', () => {
-    it('should delete a team', async () => {
+describe('deleteGroup', () => {
+    it('should delete a group', async () => {
         const app = await App.create({
             definition: {
                 name: 'Test App',
                 defaultPage: 'Test Page',
                 security: {
-                    teams: {
+                    groups: {
                         join: 'anyone',
                         invite: [],
                     },
@@ -128,37 +129,38 @@ describe('deleteTeam', () => {
             vapidPrivateKey: 'b',
             OrganizationId: organization.id,
         });
-        const team = await Team.create({
+        const group = await Group.create({
             AppId: app.id,
             name: 'test',
         });
-        const clientCredentials = await authorizeCLI('teams:write', testApp);
-        await deleteTeam({
+        const clientCredentials = await authorizeCLI('groups:write', testApp);
+        await deleteGroup({
             appId: app.id,
-            id: team.id,
+            id: group.id,
             remote: testApp.defaults.baseURL,
             clientCredentials,
         });
-        expect(team).toMatchInlineSnapshot(`
+        expect(group).toMatchInlineSnapshot(`
       {
         "AppId": 1,
         "annotations": null,
         "created": 1970-01-01T00:00:00.000Z,
+        "demo": false,
         "id": 1,
         "name": "test",
         "updated": 1970-01-01T00:00:00.000Z,
       }
     `);
-        const foundTeam = await Team.findOne();
-        expect(foundTeam).toBeNull();
+        const foundGroup = await Group.findOne();
+        expect(foundGroup).toBeNull();
     });
-    it('should throw an error if the team does not exist', async () => {
+    it('should throw an error if the group does not exist', async () => {
         const app = await App.create({
             definition: {
                 name: 'Test App',
                 defaultPage: 'Test Page',
                 security: {
-                    teams: {
+                    groups: {
                         join: 'anyone',
                         invite: [],
                     },
@@ -176,18 +178,18 @@ describe('deleteTeam', () => {
             vapidPrivateKey: 'b',
             OrganizationId: organization.id,
         });
-        const clientCredentials = await authorizeCLI('teams:write', testApp);
-        await expect(() => deleteTeam({ appId: app.id, id: 1, remote: testApp.defaults.baseURL, clientCredentials })).rejects.toThrow('Request failed with status code 404');
+        const clientCredentials = await authorizeCLI('groups:write', testApp);
+        await expect(() => deleteGroup({ appId: app.id, id: 1, remote: testApp.defaults.baseURL, clientCredentials })).rejects.toThrow('Request failed with status code 404');
     });
 });
-describe('updateTeam', () => {
-    it('should update a team', async () => {
+describe('updateGroup', () => {
+    it('should update a group', async () => {
         const app = await App.create({
             definition: {
                 name: 'Test App',
                 defaultPage: 'Test Page',
                 security: {
-                    teams: {
+                    groups: {
                         join: 'anyone',
                         invite: [],
                     },
@@ -205,36 +207,37 @@ describe('updateTeam', () => {
             vapidPrivateKey: 'b',
             OrganizationId: organization.id,
         });
-        const team = await Team.create({
+        const group = await Group.create({
             AppId: app.id,
             name: 'test',
         });
-        await authorizeCLI('teams:write', testApp);
-        await updateTeam({
+        await authorizeCLI('groups:write', testApp);
+        await updateGroup({
             appId: app.id,
-            id: team.id,
+            id: group.id,
             remote: testApp.defaults.baseURL,
             name: 'test2',
         });
-        await team.reload();
-        expect(team).toMatchInlineSnapshot(`
+        await group.reload();
+        expect(group).toMatchInlineSnapshot(`
       {
         "AppId": 1,
         "annotations": null,
         "created": 1970-01-01T00:00:00.000Z,
+        "demo": false,
         "id": 1,
         "name": "test2",
         "updated": 1970-01-01T00:00:00.000Z,
       }
     `);
     });
-    it('should throw an error if the team does not exist', async () => {
+    it('should throw an error if the group does not exist', async () => {
         const app = await App.create({
             definition: {
                 name: 'Test App',
                 defaultPage: 'Test Page',
                 security: {
-                    teams: {
+                    groups: {
                         join: 'anyone',
                         invite: [],
                     },
@@ -252,15 +255,15 @@ describe('updateTeam', () => {
             vapidPrivateKey: 'b',
             OrganizationId: organization.id,
         });
-        const team = await Team.create({
+        const group = await Group.create({
             AppId: app.id,
             name: 'test',
         });
-        await team.destroy();
-        const clientCredentials = await authorizeCLI('teams:write', testApp);
-        await expect(() => updateTeam({
+        await group.destroy();
+        const clientCredentials = await authorizeCLI('groups:write', testApp);
+        await expect(() => updateGroup({
             appId: app.id,
-            id: team.id,
+            id: group.id,
             remote: testApp.defaults.baseURL,
             name: 'test2',
             clientCredentials,
@@ -272,7 +275,7 @@ describe('updateTeam', () => {
                 name: 'Test App',
                 defaultPage: 'Test Page',
                 security: {
-                    teams: {
+                    groups: {
                         join: 'anyone',
                         invite: [],
                     },
@@ -290,26 +293,26 @@ describe('updateTeam', () => {
             vapidPrivateKey: 'b',
             OrganizationId: organization.id,
         });
-        const team = await Team.create({
+        const group = await Group.create({
             AppId: app.id,
             name: 'test',
         });
-        await expect(() => updateTeam({
+        await expect(() => updateGroup({
             appId: app.id,
-            id: team.id,
+            id: group.id,
             remote: testApp.defaults.baseURL,
             name: 'test2',
         })).rejects.toThrow('Request failed with status code 401');
     });
 });
 describe('inviteMember', () => {
-    it('should invite a member to a team', async () => {
+    it('should invite a member to a group', async () => {
         const app = await App.create({
             definition: {
                 name: 'Test App',
                 defaultPage: 'Test Page',
                 security: {
-                    teams: {
+                    groups: {
                         join: 'anyone',
                         invite: [],
                     },
@@ -327,7 +330,7 @@ describe('inviteMember', () => {
             vapidPrivateKey: 'b',
             OrganizationId: organization.id,
         });
-        const team = await Team.create({
+        const group = await Group.create({
             AppId: app.id,
             name: 'test',
         });
@@ -338,33 +341,34 @@ describe('inviteMember', () => {
             role: 'Manager',
             name: user.name,
         });
-        await authorizeCLI('teams:write', testApp);
+        await authorizeCLI('groups:write', testApp);
         await inviteMember({
             appId: app.id,
-            id: team.id,
+            id: group.id,
             remote: testApp.defaults.baseURL,
-            user: user.id,
+            user: user.primaryEmail,
         });
-        const member = await TeamMember.findOne();
-        expect(member.dataValues).toMatchInlineSnapshot({
-            AppMemberId: expect.any(String),
+        const invite = await GroupInvite.findOne();
+        expect(invite.dataValues).toMatchInlineSnapshot({
+            key: expect.any(String),
         }, `
       {
-        "AppMemberId": Any<String>,
-        "TeamId": 1,
+        "GroupId": 1,
         "created": 1970-01-01T00:00:00.000Z,
-        "role": "member",
+        "email": "test@example.com",
+        "key": Any<String>,
+        "role": "Member",
         "updated": 1970-01-01T00:00:00.000Z,
       }
     `);
     });
-    it('should throw an error if the user is not AppMember', async () => {
+    it('should throw an error if the group does not exist', async () => {
         const app = await App.create({
             definition: {
                 name: 'Test App',
                 defaultPage: 'Test Page',
                 security: {
-                    teams: {
+                    groups: {
                         join: 'anyone',
                         invite: [],
                     },
@@ -382,54 +386,23 @@ describe('inviteMember', () => {
             vapidPrivateKey: 'b',
             OrganizationId: organization.id,
         });
-        const team = await Team.create({
-            AppId: app.id,
-            name: 'test',
-        });
-        await authorizeCLI('teams:write', testApp);
-        await expect(() => inviteMember({ appId: app.id, id: team.id, remote: testApp.defaults.baseURL, user: user.id })).rejects.toThrow('Request failed with status code 404');
-    });
-    it('should throw an error if the team does not exist', async () => {
-        const app = await App.create({
-            definition: {
-                name: 'Test App',
-                defaultPage: 'Test Page',
-                security: {
-                    teams: {
-                        join: 'anyone',
-                        invite: [],
-                    },
-                    default: {
-                        role: 'Reader',
-                        policy: 'everyone',
-                    },
-                    roles: {
-                        Reader: {},
-                    },
-                },
-            },
-            path: 'test-app',
-            vapidPublicKey: 'a',
-            vapidPrivateKey: 'b',
-            OrganizationId: organization.id,
-        });
-        const team = await Team.create({
-            AppId: app.id,
-            name: 'test',
-        });
-        await team.destroy();
-        await authorizeCLI('teams:write', testApp);
-        await expect(() => inviteMember({ appId: app.id, id: team.id, remote: testApp.defaults.baseURL, user: user.id })).rejects.toThrow('Request failed with status code 404');
+        await authorizeCLI('groups:write', testApp);
+        await expect(() => inviteMember({
+            appId: app.id,
+            id: 10,
+            remote: testApp.defaults.baseURL,
+            user: user.primaryEmail,
+        })).rejects.toThrow('Request failed with status code 400');
     });
 });
 describe('updateMember', () => {
-    it('should update role of a team member', async () => {
+    it('should update role of a group member', async () => {
         const app = await App.create({
             definition: {
                 name: 'Test App',
                 defaultPage: 'Test Page',
                 security: {
-                    teams: {
+                    groups: {
                         join: 'anyone',
                         invite: [],
                     },
@@ -447,7 +420,7 @@ describe('updateMember', () => {
             vapidPrivateKey: 'b',
             OrganizationId: organization.id,
         });
-        const team = await Team.create({
+        const group = await Group.create({
             AppId: app.id,
             name: 'test',
         });
@@ -458,29 +431,29 @@ describe('updateMember', () => {
             role: 'Manager',
             name: user.name,
         });
-        const teamMember = await TeamMember.create({
-            TeamId: team.id,
+        const groupMember = await GroupMember.create({
+            GroupId: group.id,
             AppMemberId: member.id,
         });
-        await authorizeCLI('teams:write', testApp);
+        await authorizeCLI('groups:write', testApp);
         await updateMember({
             appId: app.id,
             remote: testApp.defaults.baseURL,
-            user: user.id,
-            role: TeamRole.Manager,
-            id: team.id,
+            user: groupMember.id,
+            role: 'GroupMembersManager',
+            id: group.id,
         });
-        expect(teamMember.role).toBe('member');
-        await teamMember.reload();
-        expect(teamMember.role).toBe('manager');
+        expect(groupMember.role).toBe('Member');
+        await groupMember.reload();
+        expect(groupMember.role).toBe('GroupMembersManager');
     });
-    it('should throw an error if the user is not a TeamMember', async () => {
+    it('should throw an error if the user is not a GroupMember', async () => {
         const app = await App.create({
             definition: {
                 name: 'Test App',
                 defaultPage: 'Test Page',
                 security: {
-                    teams: {
+                    groups: {
                         join: 'anyone',
                         invite: [],
                     },
@@ -498,7 +471,7 @@ describe('updateMember', () => {
             vapidPrivateKey: 'b',
             OrganizationId: organization.id,
         });
-        const team = await Team.create({
+        const group = await Group.create({
             AppId: app.id,
             name: 'test',
         });
@@ -509,24 +482,24 @@ describe('updateMember', () => {
             role: 'Manager',
             name: user.name,
         });
-        await authorizeCLI('teams:write', testApp);
+        await authorizeCLI('groups:write', testApp);
         await expect(() => updateMember({
             appId: app.id,
             remote: testApp.defaults.baseURL,
             user: user.id,
-            role: TeamRole.Manager,
-            id: team.id,
-        })).rejects.toThrow('Request failed with status code 400');
+            role: 'GroupMembersManager',
+            id: group.id,
+        })).rejects.toThrow('Request failed with status code 404');
     });
 });
 describe('deleteMember', () => {
-    it('should delete a team member', async () => {
+    it('should delete a group member', async () => {
         const app = await App.create({
             definition: {
                 name: 'Test App',
                 defaultPage: 'Test Page',
                 security: {
-                    teams: {
+                    groups: {
                         join: 'anyone',
                         invite: [],
                     },
@@ -544,7 +517,7 @@ describe('deleteMember', () => {
             vapidPrivateKey: 'b',
             OrganizationId: organization.id,
         });
-        const team = await Team.create({
+        const group = await Group.create({
             AppId: app.id,
             name: 'test',
         });
@@ -552,30 +525,36 @@ describe('deleteMember', () => {
             email: user.primaryEmail,
             AppId: app.id,
             UserId: user.id,
-            role: 'Manager',
+            role: 'Maintainer',
             name: user.name,
         });
-        await TeamMember.create({
-            TeamId: team.id,
+        await authorizeCLI('groups:write', testApp);
+        await createTestUser('test2@example.com');
+        const member2 = await createTestAppMember(app.id, 'test2@example.com');
+        await GroupMember.create({
+            GroupId: group.id,
             AppMemberId: member.id,
         });
-        await authorizeCLI('teams:write', testApp);
+        const { id: groupMemberId } = await GroupMember.create({
+            GroupId: group.id,
+            AppMemberId: member2.id,
+        });
         await deleteMember({
-            id: team.id,
+            id: group.id,
             appId: app.id,
-            user: user.id,
+            user: groupMemberId,
             remote: testApp.defaults.baseURL,
         });
-        const foundTeamMember = await TeamMember.findOne();
-        expect(foundTeamMember).toBeNull();
+        const foundGroupMember = await GroupMember.findByPk(groupMemberId);
+        expect(foundGroupMember).toBeNull();
     });
-    it('should throw an error if the TeamMember does not exist', async () => {
+    it('should throw an error if the GroupMember does not exist', async () => {
         const app = await App.create({
             definition: {
                 name: 'Test App',
                 defaultPage: 'Test Page',
                 security: {
-                    teams: {
+                    groups: {
                         join: 'anyone',
                         invite: [],
                     },
@@ -593,7 +572,7 @@ describe('deleteMember', () => {
             vapidPrivateKey: 'b',
             OrganizationId: organization.id,
         });
-        const team = await Team.create({
+        const group = await Group.create({
             AppId: app.id,
             name: 'test',
         });
@@ -604,12 +583,17 @@ describe('deleteMember', () => {
             role: 'Manager',
             name: user.name,
         });
-        await authorizeCLI('teams:write', testApp);
-        await expect(() => deleteMember({ appId: app.id, remote: testApp.defaults.baseURL, user: user.id, id: team.id })).rejects.toThrow('Request failed with status code 400');
+        await authorizeCLI('groups:write', testApp);
+        await expect(() => deleteMember({
+            appId: app.id,
+            remote: testApp.defaults.baseURL,
+            user: user.id,
+            id: group.id,
+        })).rejects.toThrow('Request failed with status code 404');
     });
 });
 describe('resolveAnnotations', () => {
-    it('should resolve team annotations', () => {
+    it('should resolve group annotations', () => {
         const unresolvedAnnotations = ['foo=bar', 'hello=world'];
         const annotations = resolveAnnotations(unresolvedAnnotations);
         expect(annotations).toMatchObject({
@@ -622,4 +606,4 @@ describe('resolveAnnotations', () => {
         expect(() => resolveAnnotations(unresolvedAnnotations)).toThrow('One of the annotations did not follow the pattern of key=value');
     });
 });
-//# sourceMappingURL=team.test.js.map
+//# sourceMappingURL=group.test.js.map

package/lib/organization.test.js

@@ -1,5 +1,6 @@
 import { createFixtureStream, readFixture } from '@appsemble/node-utils';
 import { createServer, createTestUser, models, setArgv, useTestDatabase } from '@appsemble/server';
+import { PredefinedOrganizationRole } from '@appsemble/types';
 import { setTestApp } from 'axios-test-instance';
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 import { initAxios } from './initAxios.js';
@@ -73,7 +74,7 @@ describe('updateOrganization', () => {
         await OrganizationMember.create({
             OrganizationId: organization.id,
             UserId: user.id,
-            role: 'Owner',
+            role: PredefinedOrganizationRole.Owner,
         });
         await authorizeCLI('organizations:write', testApp);
         await updateOrganization({
@@ -109,7 +110,7 @@ describe('updateOrganization', () => {
         await OrganizationMember.create({
             OrganizationId: organization.id,
             UserId: user.id,
-            role: 'Owner',
+            role: PredefinedOrganizationRole.Owner,
         });
         await organization.destroy();
         await authorizeCLI('organizations:write', testApp);
@@ -130,7 +131,7 @@ describe('updateOrganization', () => {
         await OrganizationMember.create({
             OrganizationId: organization.id,
             UserId: user.id,
-            role: 'Owner',
+            role: PredefinedOrganizationRole.Owner,
         });
         await expect(() => updateOrganization({
             id: organization.id,
@@ -171,7 +172,7 @@ describe('upsertOrganization', () => {
         await OrganizationMember.create({
             OrganizationId: organization.id,
             UserId: user.id,
-            role: 'Owner',
+            role: PredefinedOrganizationRole.Owner,
         });
         await authorizeCLI('organizations:write', testApp);
         await upsertOrganization({

package/lib/resource.js

@@ -16,12 +16,13 @@ export async function publishResource({ appId, definition, path, publishedResour
     }
     logger.info(`Publishing resource(s) from ${path}`);
     let data;
-    const endpoint = `/api/apps/${appId}/${seed ? 'seed-' : ''}resources/${type}`;
+    const endpoint = `/api/apps/${appId}/resources/${type}`;
     try {
         if (csv) {
             const response = await axios.post(endpoint, resources, {
                 baseURL: remote,
                 headers: { 'content-type': 'text/csv' },
+                params: { seed },
             });
             data = response.data;
         }
@@ -37,6 +38,7 @@ export async function publishResource({ appId, definition, path, publishedResour
             }), {
                 baseURL: remote,
                 headers: { 'content-type': 'application/json' },
+                params: { seed },
             });
             data = response.data;
         }

package/lib/resource.test.js

@@ -1,5 +1,6 @@
 import { resolveFixture } from '@appsemble/node-utils';
 import { createServer, createTestUser, models, setArgv, useTestDatabase } from '@appsemble/server';
+import { PredefinedOrganizationRole } from '@appsemble/types';
 import { setTestApp } from 'axios-test-instance';
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 import { initAxios } from './initAxios.js';
@@ -29,7 +30,7 @@ beforeEach(async () => {
     await OrganizationMember.create({
         OrganizationId: organization.id,
         UserId: user.id,
-        role: 'Owner',
+        role: PredefinedOrganizationRole.Owner,
     });
     await Organization.create({ id: 'appsemble', name: 'Appsemble' });
 });

package/lib/serverImport.d.ts

@@ -4,4 +4,4 @@
  * @param members The names of the exported member to import.
  * @returns The exported member.
  */
-export declare function serverImport<T extends 'checkDownMigrations' | 'checkMigrations' | 'cleanupDemoUsers' | 'cleanupResourcesAndAssets' | 'fuzzMigrations' | 'migrate' | 'runCronJobs' | 'scaleContainers' | 'setArgv' | 'start'>(...members: T[]): Promise<Record<T, any>>;
+export declare function serverImport<T extends 'checkDownMigrations' | 'checkMigrations' | 'cleanupDemoUsers' | 'cleanupResourcesAndAssets' | 'fuzzMigrations' | 'migrate' | 'migrateAppDefinitions' | 'runCronJobs' | 'scaleContainers' | 'setArgv' | 'start'>(...members: T[]): Promise<Record<T, any>>;