@appsemble/node-utils 0.30.14-test.5 → 0.32.1-test.14

package/server/controllers/common/apps/resources/resources.test.js

@@ -1,580 +0,0 @@
-import { defaultLocale, remap } from '@appsemble/utils';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { createCountAppResourcesController } from './createCountAppResourcesController.js';
-import { createCreateAppResourceController } from './createCreateAppResourceController.js';
-import { createGetAppResourceByIdController } from './createGetAppResourceByIdController.js';
-import { createQueryAppResourcesController } from './createQueryAppResourcesController.js';
-import { getRemapperContext } from '../../../../../app.js';
-import { getResourceDefinition } from '../../../../../resource.js';
-let mockGetApp;
-let mockGetAppResources;
-let mockGetAppResource;
-let mockParseQuery;
-let mockGetAppUrl;
-let mockGetAppMessages;
-let mockGetAppVariables;
-let mockCreateAppResourcesWithAssets;
-let mockGetAppAssets;
-let mockCheckAppPermissions;
-let mockGetCurrentAppMember;
-let mockCtx;
-let mockCtxIs;
-describe('createQueryResources', () => {
-    beforeEach(() => {
-        mockGetApp = vi.fn();
-        mockGetAppResources = vi.fn();
-        mockParseQuery = vi.fn();
-        mockGetAppUrl = vi.fn();
-        mockGetAppMessages = vi.fn();
-        mockGetAppVariables = vi.fn();
-        mockCheckAppPermissions = vi.fn();
-        mockGetCurrentAppMember = vi.fn();
-        mockCtx = {
-            pathParams: { appId: 1, resourceType: 'mockResourceType' },
-            queryParams: { $select: 'field1, field2', $skip: 0, $top: 10 },
-            user: { id: 'mockUserId', name: 'John Doe', primaryEmail: 'john@example.com' },
-        };
-    });
-    it('should fetch app and resources with correct parameters', async () => {
-        const mockApp = {
-            id: 1,
-            definition: {
-                resources: {
-                    mockResourceType: { id: 'id', schema: {} },
-                },
-            },
-        };
-        const mockResources = [{ id: 1 }, { id: 2 }];
-        const mockParsedQuery = {
-            order: [
-                ['mockField1', 'mockOrderAsc'],
-                ['mockField2', 'mockOrderDesc'],
-            ],
-            where: { mockField: 'mockValue' },
-        };
-        mockGetApp.mockResolvedValue(mockApp);
-        mockGetAppResources.mockResolvedValue(mockResources);
-        mockParseQuery.mockReturnValue(mockParsedQuery);
-        const middleware = createQueryAppResourcesController({
-            getApp: mockGetApp,
-            getAppResources: mockGetAppResources,
-            parseQuery: mockParseQuery,
-            checkAppPermissions: mockCheckAppPermissions,
-        });
-        await middleware(mockCtx, vi.fn());
-        expect(mockGetApp).toHaveBeenCalledWith(expect.objectContaining({
-            context: expect.objectContaining({
-                pathParams: expect.objectContaining({ appId: 1 }),
-            }),
-            query: expect.objectContaining({ where: { id: 1 } }),
-        }));
-        expect(mockGetAppResources).toHaveBeenCalledWith(expect.objectContaining({
-            app: {
-                definition: {
-                    resources: {
-                        mockResourceType: {
-                            id: 'id',
-                            schema: {},
-                        },
-                    },
-                },
-                id: 1,
-            },
-            context: expect.objectContaining({
-                pathParams: expect.objectContaining({
-                    appId: 1,
-                    resourceType: 'mockResourceType',
-                }),
-                queryParams: expect.objectContaining({
-                    $select: 'field1, field2',
-                    $skip: 0,
-                    $top: 10,
-                }),
-                user: expect.objectContaining({
-                    id: 'mockUserId',
-                    name: 'John Doe',
-                    primaryEmail: 'john@example.com',
-                }),
-            }),
-            findOptions: expect.objectContaining({
-                attributes: ['field1', 'field2'],
-                limit: 10,
-                offset: 0,
-                order: expect.arrayContaining([
-                    ['mockField1', 'mockOrderAsc'],
-                    ['mockField2', 'mockOrderDesc'],
-                ]),
-                where: expect.objectContaining({
-                    and: expect.arrayContaining([
-                        expect.objectContaining({ mockField: 'mockValue' }),
-                        expect.objectContaining({
-                            AppId: 1,
-                            expires: expect.objectContaining({
-                                or: expect.arrayContaining([{ gt: expect.any(Date) }, null]),
-                            }),
-                            type: 'mockResourceType',
-                        }),
-                    ]),
-                }),
-            }),
-            type: 'mockResourceType',
-        }));
-    });
-    it('should set the response body to resources when no view is specified', async () => {
-        const mockApp = {
-            id: 1,
-            definition: {
-                resources: {
-                    mockResourceType: { id: 'id', schema: {} },
-                },
-            },
-        };
-        const mockResources = [{ id: 1 }, { id: 2 }];
-        const mockParsedQuery = {
-            order: [
-                ['mockField1', 'mockOrderAsc'],
-                ['mockField2', 'mockOrderDesc'],
-            ],
-            where: { mockField: 'mockValue' },
-        };
-        mockGetApp.mockResolvedValue(mockApp);
-        mockGetAppResources.mockResolvedValue(mockResources);
-        mockParseQuery.mockReturnValue(mockParsedQuery);
-        const middleware = createQueryAppResourcesController({
-            getApp: mockGetApp,
-            getAppResources: mockGetAppResources,
-            parseQuery: mockParseQuery,
-            checkAppPermissions: mockCheckAppPermissions,
-        });
-        await middleware(mockCtx, vi.fn());
-        expect(mockCtx.body).toStrictEqual(mockResources);
-    });
-    it('should set the response body to remapped resources when view is specified', async () => {
-        const mockApp = {
-            id: 1,
-            definition: {
-                resources: {
-                    mockResourceType: { id: 'id', schema: {}, views: { view: {} } },
-                },
-            },
-        };
-        const mockResources = [{ id: 1 }, { id: 2 }];
-        const mockParsedQuery = {
-            order: [
-                ['mockField1', 'mockOrderAsc'],
-                ['mockField2', 'mockOrderDesc'],
-            ],
-            where: { mockField: 'mockValue' },
-        };
-        const mockAppUrl = new URL('https://localhost');
-        const mockAppMessages = [{ language: 'eng', messages: {} }];
-        const mockAppVariables = [{ name: 'variable', value: 'variable' }];
-        mockGetApp.mockResolvedValue(mockApp);
-        mockGetAppResources.mockResolvedValue(mockResources);
-        mockParseQuery.mockReturnValue(mockParsedQuery);
-        mockGetAppUrl.mockResolvedValue(mockAppUrl);
-        mockGetAppMessages.mockResolvedValue(mockAppMessages);
-        mockGetAppVariables.mockResolvedValue(mockAppVariables);
-        mockCtx.queryParams.view = 'view';
-        const options = {
-            getApp: mockGetApp,
-            getAppResources: mockGetAppResources,
-            parseQuery: mockParseQuery,
-            getAppUrl: mockGetAppUrl,
-            getAppMessages: mockGetAppMessages,
-            getAppVariables: mockGetAppVariables,
-            getCurrentAppMember: mockGetCurrentAppMember,
-            checkAppPermissions: mockCheckAppPermissions,
-        };
-        const resourceDefinition = getResourceDefinition(mockApp.definition, 'mockResourceType', mockCtx, 'view');
-        const remapperContext = await getRemapperContext(mockApp, mockApp.definition.defaultLanguage || defaultLocale, options, mockCtx);
-        const remappedResources = mockResources.map((resource) => remap(resourceDefinition.views.view.remap, resource, remapperContext));
-        const middleware = createQueryAppResourcesController(options);
-        await middleware(mockCtx, vi.fn());
-        expect(mockCtx.body).toStrictEqual(remappedResources);
-    });
-});
-describe('createCountResources', () => {
-    beforeEach(() => {
-        mockGetApp = vi.fn();
-        mockGetAppResources = vi.fn();
-        mockParseQuery = vi.fn();
-        mockCtx = {
-            pathParams: { appId: 1, resourceType: 'mockResourceType' },
-            queryParams: {},
-            user: { id: 'mockUserId', name: 'John Doe', primaryEmail: 'john@example.com' },
-        };
-    });
-    it('should fetch app and resources with correct parameters', async () => {
-        const mockApp = {
-            id: 1,
-            definition: {
-                resources: {
-                    mockResourceType: { id: 'id', schema: {} },
-                },
-            },
-        };
-        const mockResources = [{ id: 1 }, { id: 2 }];
-        const mockParsedQuery = {
-            order: [
-                ['mockField1', 'mockOrderAsc'],
-                ['mockField2', 'mockOrderDesc'],
-            ],
-            where: { mockField: 'mockValue' },
-        };
-        mockGetApp.mockResolvedValue(mockApp);
-        mockGetAppResources.mockResolvedValue(mockResources);
-        mockParseQuery.mockReturnValue(mockParsedQuery);
-        const middleware = createCountAppResourcesController({
-            getApp: mockGetApp,
-            getAppResources: mockGetAppResources,
-            parseQuery: mockParseQuery,
-            checkAppPermissions: mockCheckAppPermissions,
-        });
-        await middleware(mockCtx, vi.fn());
-        expect(mockGetApp).toHaveBeenCalledWith(expect.objectContaining({
-            context: expect.objectContaining({
-                pathParams: expect.objectContaining({ appId: 1 }),
-            }),
-            query: expect.objectContaining({ where: { id: 1 } }),
-        }));
-        expect(mockGetAppResources).toHaveBeenCalledWith(expect.objectContaining({
-            app: {
-                definition: {
-                    resources: {
-                        mockResourceType: {
-                            id: 'id',
-                            schema: {},
-                        },
-                    },
-                },
-                id: 1,
-            },
-            context: expect.objectContaining({
-                pathParams: expect.objectContaining({
-                    appId: 1,
-                    resourceType: 'mockResourceType',
-                }),
-                user: expect.objectContaining({
-                    id: 'mockUserId',
-                    name: 'John Doe',
-                    primaryEmail: 'john@example.com',
-                }),
-            }),
-            findOptions: expect.objectContaining({
-                where: expect.objectContaining({
-                    and: expect.arrayContaining([
-                        expect.objectContaining({ mockField: 'mockValue' }),
-                        expect.objectContaining({
-                            AppId: 1,
-                            expires: expect.objectContaining({
-                                or: expect.arrayContaining([{ gt: expect.any(Date) }, null]),
-                            }),
-                            type: 'mockResourceType',
-                        }),
-                    ]),
-                }),
-            }),
-            type: 'mockResourceType',
-        }));
-    });
-    it('should set the response body to resources count', async () => {
-        const mockApp = {
-            id: 1,
-            definition: {
-                resources: {
-                    mockResourceType: { id: 'id', schema: {} },
-                },
-            },
-        };
-        const mockResources = [{ id: 1 }, { id: 2 }];
-        const mockParsedQuery = {
-            order: [
-                ['mockField1', 'mockOrderAsc'],
-                ['mockField2', 'mockOrderDesc'],
-            ],
-            where: { mockField: 'mockValue' },
-        };
-        mockGetApp.mockResolvedValue(mockApp);
-        mockGetAppResources.mockResolvedValue(mockResources);
-        mockParseQuery.mockReturnValue(mockParsedQuery);
-        const middleware = createCountAppResourcesController({
-            getApp: mockGetApp,
-            getAppResources: mockGetAppResources,
-            parseQuery: mockParseQuery,
-            checkAppPermissions: mockCheckAppPermissions,
-        });
-        await middleware(mockCtx, vi.fn());
-        expect(mockCtx.body).toStrictEqual(mockResources.length);
-    });
-});
-describe('createGetResourceById', () => {
-    beforeEach(() => {
-        mockGetApp = vi.fn();
-        mockGetAppResource = vi.fn();
-        mockGetAppUrl = vi.fn();
-        mockGetAppMessages = vi.fn();
-        mockGetAppVariables = vi.fn();
-        mockCtx = {
-            pathParams: { appId: 1, resourceId: 1, resourceType: 'mockResourceType' },
-            user: { id: 'mockUserId', name: 'John Doe', primaryEmail: 'john@example.com' },
-            queryParams: {},
-        };
-    });
-    it('should fetch app and resource with correct parameters', async () => {
-        const mockApp = {
-            id: 1,
-            definition: {
-                resources: {
-                    mockResourceType: { id: 'id', schema: {} },
-                },
-            },
-        };
-        const mockResource = { id: 1 };
-        mockGetApp.mockResolvedValue(mockApp);
-        mockGetAppResource.mockResolvedValue(mockResource);
-        const middleware = createGetAppResourceByIdController({
-            getApp: mockGetApp,
-            getAppResource: mockGetAppResource,
-            parseQuery: mockParseQuery,
-            checkAppPermissions: mockCheckAppPermissions,
-        });
-        await middleware(mockCtx, vi.fn());
-        expect(mockGetApp).toHaveBeenCalledWith(expect.objectContaining({
-            context: expect.objectContaining({
-                pathParams: expect.objectContaining({ appId: 1 }),
-            }),
-            query: expect.objectContaining({ where: { id: 1 } }),
-        }));
-        expect(mockGetAppResource).toHaveBeenCalledWith(expect.objectContaining({
-            app: {
-                definition: {
-                    resources: {
-                        mockResourceType: {
-                            id: 'id',
-                            schema: {},
-                        },
-                    },
-                },
-                id: 1,
-            },
-            id: 1,
-            type: 'mockResourceType',
-            context: expect.objectContaining({
-                pathParams: expect.objectContaining({
-                    appId: 1,
-                    resourceType: 'mockResourceType',
-                }),
-                user: expect.objectContaining({
-                    id: 'mockUserId',
-                    name: 'John Doe',
-                    primaryEmail: 'john@example.com',
-                }),
-            }),
-            findOptions: expect.objectContaining({
-                where: expect.objectContaining({
-                    id: 1,
-                    type: 'mockResourceType',
-                    AppId: 1,
-                    expires: expect.objectContaining({
-                        or: expect.arrayContaining([{ gt: expect.any(Date) }, null]),
-                    }),
-                }),
-            }),
-        }));
-    });
-    it('should set the response body to resource when no view is specified', async () => {
-        const mockApp = {
-            id: 1,
-            definition: {
-                resources: {
-                    mockResourceType: { id: 'id', schema: {} },
-                },
-            },
-        };
-        const mockResource = { id: 1 };
-        mockGetApp.mockResolvedValue(mockApp);
-        mockGetAppResource.mockResolvedValue(mockResource);
-        const middleware = createGetAppResourceByIdController({
-            getApp: mockGetApp,
-            getAppResource: mockGetAppResource,
-            checkAppPermissions: mockCheckAppPermissions,
-            parseQuery: mockParseQuery,
-        });
-        await middleware(mockCtx, vi.fn());
-        expect(mockCtx.body).toStrictEqual(mockResource);
-    });
-    it('should set the response body to remapped resource when view is specified', async () => {
-        const mockApp = {
-            id: 1,
-            definition: {
-                resources: {
-                    mockResourceType: { id: 'id', schema: {}, views: { view: {} } },
-                },
-            },
-        };
-        const mockResource = { id: 1 };
-        const mockAppUrl = new URL('https://localhost');
-        const mockAppMessages = [{ language: 'eng', messages: {} }];
-        const mockAppVariables = [{ name: 'variable', value: 'variable' }];
-        mockGetApp.mockResolvedValue(mockApp);
-        mockGetAppResource.mockResolvedValue(mockResource);
-        mockGetAppUrl.mockResolvedValue(mockAppUrl);
-        mockGetAppMessages.mockResolvedValue(mockAppMessages);
-        mockGetAppVariables.mockResolvedValue(mockAppVariables);
-        mockCtx.queryParams = { view: 'view' };
-        const options = {
-            getApp: mockGetApp,
-            getAppResource: mockGetAppResource,
-            getAppUrl: mockGetAppUrl,
-            getAppMessages: mockGetAppMessages,
-            getAppVariables: mockGetAppVariables,
-            checkAppPermissions: mockCheckAppPermissions,
-            getCurrentAppMember: mockGetCurrentAppMember,
-        };
-        const resourceDefinition = getResourceDefinition(mockApp.definition, 'mockResourceType', mockCtx, 'view');
-        const remapperContext = await getRemapperContext(mockApp, mockApp.definition.defaultLanguage || defaultLocale, options, mockCtx);
-        const remappedResource = remap(resourceDefinition.views.view.remap, mockResource, remapperContext);
-        const middleware = createGetAppResourceByIdController(options);
-        await middleware(mockCtx, vi.fn());
-        expect(mockCtx.body).toStrictEqual(remappedResource);
-    });
-});
-describe('createCreateResource', () => {
-    beforeEach(() => {
-        mockGetApp = vi.fn();
-        mockCreateAppResourcesWithAssets = vi.fn();
-        mockGetAppAssets = vi.fn();
-        mockCtxIs = vi.fn();
-        mockCtx = {
-            pathParams: { appId: 1, resourceType: 'mockResourceType' },
-            user: { id: 'mockUserId', name: 'John Doe', primaryEmail: 'john@example.com' },
-            is: mockCtxIs,
-            request: {},
-            queryParams: {},
-        };
-    });
-    it('should fetch app and create multiple resources', async () => {
-        const mockApp = {
-            id: 1,
-            definition: {
-                resources: {
-                    mockResourceType: { id: 'id', schema: {} },
-                },
-            },
-        };
-        const mockResources = [{ id: 1 }, { id: 2 }];
-        mockCtx.request.body = { resource: mockResources };
-        mockGetApp.mockResolvedValue(mockApp);
-        mockCtxIs.mockReturnValue('multipart/form-data');
-        mockCreateAppResourcesWithAssets.mockResolvedValue(mockResources);
-        mockGetAppAssets.mockResolvedValue([]);
-        const middleware = createCreateAppResourceController({
-            getApp: mockGetApp,
-            createAppResourcesWithAssets: mockCreateAppResourcesWithAssets,
-            getAppAssets: mockGetAppAssets,
-            checkAppPermissions: mockCheckAppPermissions,
-            getCurrentAppMember: mockGetCurrentAppMember,
-            parseQuery: mockParseQuery,
-        });
-        await middleware(mockCtx, vi.fn());
-        expect(mockGetApp).toHaveBeenCalledWith(expect.objectContaining({
-            context: expect.objectContaining({
-                pathParams: expect.objectContaining({ appId: 1 }),
-            }),
-            query: expect.objectContaining({ where: { id: 1 } }),
-        }));
-        expect(mockCreateAppResourcesWithAssets).toHaveBeenCalledWith(expect.objectContaining({
-            app: expect.objectContaining({
-                definition: expect.objectContaining({
-                    resources: expect.objectContaining({
-                        mockResourceType: expect.objectContaining({
-                            id: 'id',
-                            schema: {},
-                        }),
-                    }),
-                }),
-                id: 1,
-            }),
-            context: expect.objectContaining({
-                request: expect.objectContaining({
-                    body: {
-                        resource: mockResources,
-                    },
-                }),
-                pathParams: expect.objectContaining({
-                    appId: 1,
-                    resourceType: 'mockResourceType',
-                }),
-                user: expect.objectContaining({
-                    id: 'mockUserId',
-                    name: 'John Doe',
-                    primaryEmail: 'john@example.com',
-                }),
-            }),
-        }));
-        expect(mockCtx.body).toStrictEqual(mockResources);
-    });
-    it('should fetch app and create a single resource', async () => {
-        const mockApp = {
-            id: 1,
-            definition: {
-                resources: {
-                    mockResourceType: { id: 'id', schema: {} },
-                },
-            },
-        };
-        const mockResources = [{ id: 1 }];
-        mockCtx.request.body = { resource: mockResources[0] };
-        mockGetApp.mockResolvedValue(mockApp);
-        mockCtxIs.mockReturnValue('multipart/form-data');
-        mockCreateAppResourcesWithAssets.mockResolvedValue(mockResources);
-        mockGetAppAssets.mockResolvedValue([]);
-        const middleware = createCreateAppResourceController({
-            getApp: mockGetApp,
-            createAppResourcesWithAssets: mockCreateAppResourcesWithAssets,
-            getAppAssets: mockGetAppAssets,
-            checkAppPermissions: mockCheckAppPermissions,
-            getCurrentAppMember: mockGetCurrentAppMember,
-            parseQuery: mockParseQuery,
-        });
-        await middleware(mockCtx, vi.fn());
-        expect(mockGetApp).toHaveBeenCalledWith(expect.objectContaining({
-            context: expect.objectContaining({
-                pathParams: expect.objectContaining({ appId: 1 }),
-            }),
-            query: expect.objectContaining({ where: { id: 1 } }),
-        }));
-        expect(mockCreateAppResourcesWithAssets).toHaveBeenCalledWith(expect.objectContaining({
-            app: expect.objectContaining({
-                definition: expect.objectContaining({
-                    resources: expect.objectContaining({
-                        mockResourceType: expect.objectContaining({
-                            id: 'id',
-                            schema: {},
-                        }),
-                    }),
-                }),
-                id: 1,
-            }),
-            context: expect.objectContaining({
-                request: expect.objectContaining({
-                    body: {
-                        resource: mockResources[0],
-                    },
-                }),
-                pathParams: expect.objectContaining({
-                    appId: 1,
-                    resourceType: 'mockResourceType',
-                }),
-                user: expect.objectContaining({
-                    id: 'mockUserId',
-                    name: 'John Doe',
-                    primaryEmail: 'john@example.com',
-                }),
-            }),
-        }));
-        expect(mockCtx.body).toStrictEqual(mockResources[0]);
-    });
-});
-//# sourceMappingURL=resources.test.js.map

package/tinyRouter.test.d.ts

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

package/tinyRouter.test.js

@@ -1,83 +0,0 @@
-import { noop } from '@appsemble/utils';
-import { request, setTestApp } from 'axios-test-instance';
-import Koa from 'koa';
-import { beforeEach, expect, it, vi } from 'vitest';
-import { errorMiddleware } from './index.js';
-import { tinyRouter } from './tinyRouter.js';
-let app;
-let context;
-beforeEach(async () => {
-    app = new Koa();
-    app.silent = true;
-    app.use((ctx, next) => {
-        context = ctx;
-        return next();
-    });
-    await setTestApp(app);
-});
-it('should assign the match group to params', async () => {
-    app.use(tinyRouter([
-        {
-            route: /^\/(?<foo>.+)\/(?<bar>.+)/,
-            get: noop,
-        },
-    ]));
-    await request.get('/1/2');
-    expect(context.params).toStrictEqual({ foo: '1', bar: '2' });
-});
-it('should throw method not allowed if a URL is matched, but not for the given method', async () => {
-    app.use(errorMiddleware());
-    app.use(tinyRouter([
-        {
-            route: '/',
-            get: noop,
-        },
-    ]));
-    await request.post('/');
-    expect(context.status).toBe(405);
-});
-it('should fall back to the any handler if it exists', async () => {
-    const any = vi.fn();
-    app.use(tinyRouter([
-        {
-            route: '/',
-            any,
-        },
-    ]));
-    await request.post('/');
-    expect(any).toHaveBeenCalledWith(context, expect.any(Function));
-});
-it('should pick method specific middleware over any', async () => {
-    const any = vi.fn();
-    const get = vi.fn();
-    app.use(tinyRouter([
-        {
-            route: '/',
-            any,
-            get,
-        },
-    ]));
-    await request.get('/');
-    expect(any).not.toHaveBeenCalled();
-    expect(get).toHaveBeenCalledWith(context, expect.any(Function));
-});
-it('should not call next if there are matching routes', async () => {
-    const middleware = vi.fn();
-    app.use(tinyRouter([
-        {
-            route: '/',
-            get: noop,
-        },
-    ]));
-    app.use(middleware);
-    await request.get('/');
-    expect(middleware).not.toHaveBeenCalled();
-});
-it('should call next if there are no matching routes', async () => {
-    const middleware = vi.fn();
-    app.use(tinyRouter([]));
-    app.use(middleware);
-    await request.get('/');
-    expect(middleware).toHaveBeenCalledWith(context, expect.any(Function));
-});
-//# sourceMappingURL=tinyRouter.test.js.map

package/versions.cjs

@@ -1,4 +0,0 @@
-// Ts-node doesn’t understand this if it’s written as TypeScript.
-module.exports.faVersion = require('@fortawesome/fontawesome-free/package.json').version;
-module.exports.bulmaVersion = require('bulma/package.json').version;
-module.exports.version = require('./package.json').version;