@appsemble/cli 0.27.12 → 0.28.0

package/lib/asset.test.js

@@ -0,0 +1,101 @@
+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 { publishAsset } from './asset.js';
+import { initAxios } from './initAxios.js';
+import { authorizeCLI } from './testUtils.js';
+const argv = { host: 'http://localhost', secret: 'test', aesSecret: 'testSecret' };
+let user;
+let organization;
+let testApp;
+const { App, Asset, 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();
+    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('publishAsset', () => {
+    it('should publish an asset from a file', async () => {
+        const app = await App.create({
+            path: 'test-app',
+            definition: { name: 'Test App', defaultPage: 'Test Page' },
+            vapidPublicKey: 'a',
+            vapidPrivateKey: 'b',
+            visibility: 'public',
+            OrganizationId: organization.id,
+        });
+        await authorizeCLI('assets:write', testApp);
+        await publishAsset({
+            appId: app.id,
+            clonable: false,
+            name: 'test',
+            path: resolveFixture('apps/tux.png'),
+            remote: testApp.defaults.baseURL,
+            seed: false,
+        });
+        const asset = await Asset.findOne();
+        expect(asset.dataValues).toMatchInlineSnapshot({
+            id: expect.any(String),
+            data: expect.any(Buffer),
+        }, `
+      {
+        "AppId": 1,
+        "AppMemberId": null,
+        "ResourceId": null,
+        "clonable": false,
+        "created": 1970-01-01T00:00:00.000Z,
+        "data": Any<Buffer>,
+        "ephemeral": false,
+        "filename": "tux.png",
+        "id": Any<String>,
+        "mime": "image/png",
+        "name": "test",
+        "seed": false,
+        "updated": 1970-01-01T00:00:00.000Z,
+      }
+    `);
+    });
+    it('should throw an error if the app does not exist', async () => {
+        const app = await App.create({
+            path: 'test-app',
+            definition: { name: 'Test App', defaultPage: 'Test Page' },
+            vapidPublicKey: 'a',
+            vapidPrivateKey: 'b',
+            visibility: 'public',
+            OrganizationId: organization.id,
+        });
+        await app.destroy();
+        await authorizeCLI('assets:write', testApp);
+        await expect(() => publishAsset({
+            appId: app.id,
+            clonable: false,
+            name: 'test',
+            path: resolveFixture('apps/tux.png'),
+            remote: testApp.defaults.baseURL,
+            seed: false,
+        })).rejects.toThrow('Request failed with status code 404');
+    });
+});
+//# sourceMappingURL=asset.test.js.map

package/lib/block.d.ts

@@ -18,8 +18,9 @@ interface DeleteBlockVersionParams {
     blockName: string;
     blockVersion: string;
     remote: string;
+    clientCredentials?: string;
 }
-export declare function deleteBlock({ blockName, blockVersion, organization, remote, }: DeleteBlockVersionParams): Promise<void>;
+export declare function deleteBlock({ blockName, blockVersion, clientCredentials, organization, remote, }: DeleteBlockVersionParams): Promise<void>;
 /**
  * Uploads an app block theme
  *

package/lib/block.js

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
 import { mkdir, readdir, rm } from 'node:fs/promises';
 import { basename, join } from 'node:path';
-import { AppsembleError, logger, opendirSafe, readData, writeData } from '@appsemble/node-utils';
+import { AppsembleError, authenticate, logger, opendirSafe, readData, writeData, } from '@appsemble/node-utils';
 import { compareStrings } from '@appsemble/utils';
 import axios from 'axios';
 import webpack from 'webpack';
@@ -48,7 +48,8 @@ export async function buildBlock(buildConfig, env) {
         }
     });
 }
-export async function deleteBlock({ blockName, blockVersion, organization, remote, }) {
+export async function deleteBlock({ blockName, blockVersion, clientCredentials, organization, remote, }) {
+    await authenticate(remote, 'blocks:delete', clientCredentials);
     await axios.delete(`/api/blocks/@${organization}/${blockName}/versions/${blockVersion}`, {
         baseURL: remote,
     });

package/lib/block.test.js

@@ -1,7 +1,16 @@
 import { resolveFixture } from '@appsemble/node-utils';
+import { createServer, createTestUser, models, setArgv, useTestDatabase } from '@appsemble/server';
+import { setTestApp } from 'axios-test-instance';
 import concat from 'concat-stream';
-import { describe, expect, it } from 'vitest';
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { deleteBlock } from './block.js';
+import { initAxios } from './initAxios.js';
 import { makeProjectPayload } from './project.js';
+import { authorizeCLI } from './testUtils.js';
+useTestDatabase(import.meta);
+const argv = { host: 'http://localhost', secret: 'test', aesSecret: 'testSecret' };
+let testApp;
+const { BlockVersion, Organization, OrganizationMember } = models;
 describe('makeProjectPayload', () => {
     it('should create a form-data payload', async () => {
         const payload = await makeProjectPayload({
@@ -95,4 +104,46 @@ export const string = 'with-icon';
 `);
     });
 });
+describe('deleteBlock', () => {
+    let user;
+    let organization;
+    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',
+        });
+    });
+    it('should delete a block', async () => {
+        const block = await BlockVersion.create({
+            OrganizationId: organization.id,
+            name: 'test',
+            version: '0.0.0',
+        });
+        const clientCredentials = await authorizeCLI('blocks:delete', testApp);
+        await deleteBlock({
+            remote: testApp.defaults.baseURL,
+            clientCredentials,
+            blockName: block.name,
+            blockVersion: block.version,
+            organization: organization.id,
+        });
+        const foundBlocks = await BlockVersion.findAll();
+        expect(foundBlocks).toStrictEqual([]);
+    });
+});
 //# sourceMappingURL=block.test.js.map

package/lib/organization.js

@@ -55,16 +55,18 @@ export async function updateOrganization({ description, email, icon, id, name, w
     logger.info(`Successfully updated organization ${id}${name ? ` (${name})` : ''}`);
 }
 export async function upsertOrganization({ description, email, icon, id, name, website, }) {
+    var _a;
     try {
         await axios.get(`/api/organizations/${id}`);
-        updateOrganization({ description, email, icon, id, name, website });
+        await updateOrganization({ description, email, icon, id, name, website });
     }
     catch (error) {
-        if (axios.isAxiosError(error) && error.response && error.response.status === 404) {
-            createOrganization({ description, email, icon, id, name, website });
+        if (axios.isAxiosError(error) && ((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
+            await createOrganization({ description, email, icon, id, name, website });
         }
         else {
             logger.error(error);
+            throw error;
         }
     }
 }

package/lib/organization.test.d.ts

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

package/lib/organization.test.js

@@ -0,0 +1,222 @@
+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 { createOrganization, updateOrganization, upsertOrganization } from './organization.js';
+import { authorizeCLI } from './testUtils.js';
+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: null,
+            website: 'https://example.com',
+        });
+        const organization = await Organization.findOne();
+        expect(organization).toMatchInlineSnapshot(`
+      {
+        "created": 1970-01-01T00:00:00.000Z,
+        "deleted": null,
+        "description": "test description",
+        "email": "test@example.com",
+        "icon": null,
+        "id": "test",
+        "name": "Test",
+        "updated": 1970-01-01T00:00:00.000Z,
+        "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();
+    });
+});
+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',
+        });
+        await authorizeCLI('organizations:write', testApp);
+        await updateOrganization({
+            id: organization.id,
+            name: 'Test changed',
+            description: null,
+            email: 'test@example.com',
+            website: null,
+            icon: null,
+        });
+        await organization.reload();
+        expect(organization.dataValues).toMatchInlineSnapshot(`
+      {
+        "created": 1970-01-01T00:00:00.000Z,
+        "deleted": null,
+        "description": null,
+        "email": "test@example.com",
+        "icon": null,
+        "id": "test",
+        "name": "Test changed",
+        "updated": 1970-01-01T00:00:00.000Z,
+        "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',
+        });
+        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',
+        });
+    });
+});
+//# sourceMappingURL=organization.test.js.map

package/lib/resource.test.d.ts

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