@appsemble/cli 0.29.11 → 0.30.2

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 { createServer, createTestUser, models, setArgv } 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';
@@ -9,85 +10,85 @@ const argv = { host: 'http://localhost', secret: 'test', aesSecret: 'testSecret'
 let user;
 let testApp;
 const { Organization, OrganizationMember } = models;
-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();
-});
-afterAll(() => {
-    vi.useRealTimers();
-});
-describe('createOrganization', () => {
-    it('should create a new organization', async () => {
-        await authorizeCLI('organizations:write', testApp);
-        await createOrganization({
-            description: 'test description',
-            id: 'test',
-            name: 'Test',
-            email: 'test@example.com',
-            icon: createFixtureStream('apps/tux.png'),
-            website: 'https://example.com',
-        });
-        const organization = await Organization.findOne();
-        expect(organization).toMatchObject({
-            description: 'test description',
-            email: 'test@example.com',
-            icon: await readFixture('apps/tux.png'),
-            id: 'test',
-            name: 'Test',
-            website: 'https://example.com',
-        });
+describe('organization', () => {
+    beforeAll(() => {
+        vi.useFakeTimers();
+        setArgv(argv);
     });
-    it('should not create a new organization with duplicate id', async () => {
-        const organization = await Organization.create({
-            id: 'test',
-            name: 'Test',
-        });
+    beforeEach(async () => {
+        vi.clearAllTimers();
+        vi.setSystemTime(0);
+        const server = await createServer();
+        testApp = await setTestApp(server);
+        initAxios({ remote: testApp.defaults.baseURL });
+        user = await createTestUser();
+    });
+    afterAll(() => {
         vi.useRealTimers();
-        await authorizeCLI('organizations:write', testApp);
-        await expect(() => createOrganization({
-            description: 'test description',
-            id: organization.id,
-            name: 'Test',
-            email: 'test@example.com',
-            icon: null,
-            website: 'https://example.com',
-        })).rejects.toThrow('Request failed with status code 409');
-        vi.useFakeTimers();
     });
-});
-describe('updateOrganization', () => {
-    it('should update an existing organization', async () => {
-        const organization = await Organization.create({
-            id: 'test',
-            name: 'Test',
-        });
-        await OrganizationMember.create({
-            OrganizationId: organization.id,
-            UserId: user.id,
-            role: 'Owner',
+    describe('createOrganization', () => {
+        it('should create a new organization', async () => {
+            await authorizeCLI('organizations:write', testApp);
+            await createOrganization({
+                description: 'test description',
+                id: 'test',
+                name: 'Test',
+                email: 'test@example.com',
+                icon: createFixtureStream('apps/tux.png'),
+                website: 'https://example.com',
+            });
+            const organization = await Organization.findOne();
+            expect(organization).toMatchObject({
+                description: 'test description',
+                email: 'test@example.com',
+                icon: await readFixture('apps/tux.png'),
+                id: 'test',
+                name: 'Test',
+                website: 'https://example.com',
+            });
+        });
+        it('should not create a new organization with duplicate id', async () => {
+            const organization = await Organization.create({
+                id: 'test',
+                name: 'Test',
+            });
+            vi.useRealTimers();
+            await authorizeCLI('organizations:write', testApp);
+            await expect(() => createOrganization({
+                description: 'test description',
+                id: organization.id,
+                name: 'Test',
+                email: 'test@example.com',
+                icon: null,
+                website: 'https://example.com',
+            })).rejects.toThrow('Request failed with status code 409');
+            vi.useFakeTimers();
         });
-        await authorizeCLI('organizations:write', testApp);
-        await updateOrganization({
-            id: organization.id,
-            name: 'Test changed',
-            description: 'Description Changed',
-            email: 'test@example.com',
-            website: null,
-            icon: createFixtureStream('apps/tux.png'),
-        });
-        await organization.reload();
-        expect(organization.dataValues).toMatchInlineSnapshot({
-            icon: expect.any(Buffer),
-        }, `
+    });
+    describe('updateOrganization', () => {
+        it('should update an existing organization', async () => {
+            const organization = await Organization.create({
+                id: 'test',
+                name: 'Test',
+            });
+            await OrganizationMember.create({
+                OrganizationId: organization.id,
+                UserId: user.id,
+                role: PredefinedOrganizationRole.Owner,
+            });
+            await authorizeCLI('organizations:write', testApp);
+            await updateOrganization({
+                id: organization.id,
+                name: 'Test changed',
+                description: 'Description Changed',
+                email: 'test@example.com',
+                website: null,
+                icon: createFixtureStream('apps/tux.png'),
+            });
+            await organization.reload();
+            expect(organization.dataValues).toMatchInlineSnapshot({
+                icon: expect.any(Buffer),
+            }, `
       {
         "created": 1970-01-01T00:00:00.000Z,
         "deleted": null,
@@ -100,120 +101,121 @@ describe('updateOrganization', () => {
         "website": null,
       }
     `);
-    });
-    it('should throw if the organization does not exist', async () => {
-        const organization = await Organization.create({
-            id: 'test',
-            name: 'Test',
         });
-        await OrganizationMember.create({
-            OrganizationId: organization.id,
-            UserId: user.id,
-            role: 'Owner',
+        it('should throw if the organization does not exist', async () => {
+            const organization = await Organization.create({
+                id: 'test',
+                name: 'Test',
+            });
+            await OrganizationMember.create({
+                OrganizationId: organization.id,
+                UserId: user.id,
+                role: PredefinedOrganizationRole.Owner,
+            });
+            await organization.destroy();
+            await authorizeCLI('organizations:write', testApp);
+            await expect(() => updateOrganization({
+                id: organization.id,
+                name: 'Test changed',
+                description: null,
+                email: 'test@example.com',
+                website: null,
+                icon: null,
+            })).rejects.toThrow('Request failed with status code 404');
+        });
+        it('should throw if the user is not authorized', async () => {
+            const organization = await Organization.create({
+                id: 'test',
+                name: 'Test',
+            });
+            await OrganizationMember.create({
+                OrganizationId: organization.id,
+                UserId: user.id,
+                role: PredefinedOrganizationRole.Owner,
+            });
+            await expect(() => updateOrganization({
+                id: organization.id,
+                name: 'Test changed',
+                description: null,
+                email: 'test@example.com',
+                website: null,
+                icon: null,
+            })).rejects.toThrow('Request failed with status code 401');
         });
-        await organization.destroy();
-        await authorizeCLI('organizations:write', testApp);
-        await expect(() => updateOrganization({
-            id: organization.id,
-            name: 'Test changed',
-            description: null,
-            email: 'test@example.com',
-            website: null,
-            icon: null,
-        })).rejects.toThrow('Request failed with status code 404');
     });
-    it('should throw if the user is not authorized', async () => {
-        const organization = await Organization.create({
-            id: 'test',
-            name: 'Test',
-        });
-        await OrganizationMember.create({
-            OrganizationId: organization.id,
-            UserId: user.id,
-            role: 'Owner',
-        });
-        await expect(() => updateOrganization({
-            id: organization.id,
-            name: 'Test changed',
-            description: null,
-            email: 'test@example.com',
-            website: null,
-            icon: null,
-        })).rejects.toThrow('Request failed with status code 401');
-    });
-});
-describe('upsertOrganization', () => {
-    it('should create a new organization if doesn’t exist already', async () => {
-        await authorizeCLI('organizations:write', testApp);
-        await upsertOrganization({
-            description: 'test description',
-            id: 'test',
-            name: 'Test',
-            email: 'test@example.com',
-            icon: null,
-            website: 'https://example.com',
-        });
-        const organization = await Organization.findOne();
-        expect(organization).toMatchObject({
-            id: 'test',
-            description: 'test description',
-            name: 'Test',
-            email: 'test@example.com',
-            icon: null,
-            website: 'https://example.com',
-        });
-    });
-    it('should update an existing organization', async () => {
-        const organization = await Organization.create({
-            id: 'test',
-            name: 'Test',
-        });
-        await OrganizationMember.create({
-            OrganizationId: organization.id,
-            UserId: user.id,
-            role: 'Owner',
-        });
-        await authorizeCLI('organizations:write', testApp);
-        await upsertOrganization({
-            id: organization.id,
-            name: 'Test changed',
-            description: null,
-            email: 'test@example.com',
-            website: null,
-            icon: null,
-        });
-        expect(organization).toMatchObject({
-            id: 'test',
-            name: 'Test',
-        });
-        await organization.reload();
-        expect(organization).toMatchObject({
-            id: organization.id,
-            name: 'Test changed',
-            description: null,
-            email: 'test@example.com',
-            website: null,
-            icon: null,
-        });
-    });
-    it('should throw if there is an error', async () => {
-        const organization = await Organization.create({
-            id: 'test',
-            name: 'Test',
-        });
-        await authorizeCLI('organizations:write', testApp);
-        // Fails because the organization member does not exist.
-        await expect(() => upsertOrganization({
-            id: organization.id,
-            name: 'Test changed',
-            description: null,
-            email: 'test@example.com',
-            website: 'https://www.example.com',
-            icon: null,
-        })).rejects.toThrow('Request failed with status code 403');
-        expect(organization).toMatchObject({
-            id: 'test',
-            name: 'Test',
+    describe('upsertOrganization', () => {
+        it('should create a new organization if doesn’t exist already', async () => {
+            await authorizeCLI('organizations:write', testApp);
+            await upsertOrganization({
+                description: 'test description',
+                id: 'test',
+                name: 'Test',
+                email: 'test@example.com',
+                icon: null,
+                website: 'https://example.com',
+            });
+            const organization = await Organization.findOne();
+            expect(organization).toMatchObject({
+                id: 'test',
+                description: 'test description',
+                name: 'Test',
+                email: 'test@example.com',
+                icon: null,
+                website: 'https://example.com',
+            });
+        });
+        it('should update an existing organization', async () => {
+            const organization = await Organization.create({
+                id: 'test',
+                name: 'Test',
+            });
+            await OrganizationMember.create({
+                OrganizationId: organization.id,
+                UserId: user.id,
+                role: PredefinedOrganizationRole.Owner,
+            });
+            await authorizeCLI('organizations:write', testApp);
+            await upsertOrganization({
+                id: organization.id,
+                name: 'Test changed',
+                description: null,
+                email: 'test@example.com',
+                website: null,
+                icon: null,
+            });
+            expect(organization).toMatchObject({
+                id: 'test',
+                name: 'Test',
+            });
+            await organization.reload();
+            expect(organization).toMatchObject({
+                id: organization.id,
+                name: 'Test changed',
+                description: null,
+                email: 'test@example.com',
+                website: null,
+                icon: null,
+            });
+        });
+        it('should throw if there is an error', async () => {
+            const organization = await Organization.create({
+                id: 'test',
+                name: 'Test',
+            });
+            await authorizeCLI('organizations:write', testApp);
+            // Fails because the organization member does not exist.
+            await expect(() => upsertOrganization({
+                id: organization.id,
+                name: 'Test changed',
+                description: null,
+                email: 'test@example.com',
+                website: 'https://www.example.com',
+                icon: null,
+            })).rejects.toThrow('Request failed with status code 403');
+            expect(organization).toMatchObject({
+                id: 'test',
+                name: 'Test',
+            });
         });
     });
 });

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;
         }