@appsemble/node-utils 0.20.45 → 0.21.1

package/server/controllers/resources.test.js

@@ -0,0 +1,552 @@
+import { defaultLocale, remap } from '@appsemble/utils';
+import { createCountResources, createCreateResource, createGetResourceById, createQueryResources, } from './resources.js';
+import { getRemapperContext } from '../../app.js';
+import { getResourceDefinition } from '../../resource.js';
+let mockGetApp;
+let mockGetAppResources;
+let mockGetAppResource;
+let mockVerifyResourceActionPermission;
+let mockParseQuery;
+let mockGetAppUrl;
+let mockGetAppMessages;
+let mockCreateAppResourcesWithAssets;
+let mockCtx;
+let mockCtxIs;
+describe('createQueryResources', () => {
+    beforeEach(() => {
+        mockGetApp = vi.fn();
+        mockGetAppResources = vi.fn();
+        mockVerifyResourceActionPermission = vi.fn();
+        mockParseQuery = vi.fn();
+        mockGetAppUrl = vi.fn();
+        mockGetAppMessages = 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 = createQueryResources({
+            getApp: mockGetApp,
+            getAppResources: mockGetAppResources,
+            verifyResourceActionPermission: mockVerifyResourceActionPermission,
+            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(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 = createQueryResources({
+            getApp: mockGetApp,
+            getAppResources: mockGetAppResources,
+            verifyResourceActionPermission: mockVerifyResourceActionPermission,
+            parseQuery: mockParseQuery,
+        });
+        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: {} }];
+        mockGetApp.mockResolvedValue(mockApp);
+        mockGetAppResources.mockResolvedValue(mockResources);
+        mockParseQuery.mockReturnValue(mockParsedQuery);
+        mockGetAppUrl.mockResolvedValue(mockAppUrl);
+        mockGetAppMessages.mockResolvedValue(mockAppMessages);
+        mockCtx.queryParams.view = 'view';
+        const options = {
+            getApp: mockGetApp,
+            getAppResources: mockGetAppResources,
+            verifyResourceActionPermission: mockVerifyResourceActionPermission,
+            parseQuery: mockParseQuery,
+            getAppUrl: mockGetAppUrl,
+            getAppMessages: mockGetAppMessages,
+        };
+        const resourceDefinition = getResourceDefinition(mockApp, 'mockResourceType', 'view');
+        const remapperContext = await getRemapperContext(mockApp, mockApp.definition.defaultLanguage || defaultLocale, null, options, mockCtx);
+        const remappedResources = mockResources.map((resource) => remap(resourceDefinition.views.view.remap, resource, remapperContext));
+        const middleware = createQueryResources(options);
+        await middleware(mockCtx, vi.fn());
+        expect(mockCtx.body).toStrictEqual(remappedResources);
+    });
+});
+describe('createCountResources', () => {
+    beforeEach(() => {
+        mockGetApp = vi.fn();
+        mockGetAppResources = vi.fn();
+        mockVerifyResourceActionPermission = 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 = createCountResources({
+            getApp: mockGetApp,
+            getAppResources: mockGetAppResources,
+            verifyResourceActionPermission: mockVerifyResourceActionPermission,
+            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(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 = createCountResources({
+            getApp: mockGetApp,
+            getAppResources: mockGetAppResources,
+            verifyResourceActionPermission: mockVerifyResourceActionPermission,
+            parseQuery: mockParseQuery,
+        });
+        await middleware(mockCtx, vi.fn());
+        expect(mockCtx.body).toStrictEqual(mockResources.length);
+    });
+});
+describe('createGetResourceById', () => {
+    beforeEach(() => {
+        mockGetApp = vi.fn();
+        mockGetAppResource = vi.fn();
+        mockVerifyResourceActionPermission = vi.fn();
+        mockGetAppUrl = vi.fn();
+        mockGetAppMessages = vi.fn();
+        mockCtx = {
+            pathParams: { appId: 1, resourceId: 1, resourceType: 'mockResourceType' },
+            user: { id: 'mockUserId', name: 'John Doe', primaryEmail: 'john@example.com' },
+        };
+    });
+    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 = createGetResourceById({
+            getApp: mockGetApp,
+            getAppResource: mockGetAppResource,
+            verifyResourceActionPermission: mockVerifyResourceActionPermission,
+        });
+        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 = createGetResourceById({
+            getApp: mockGetApp,
+            getAppResource: mockGetAppResource,
+            verifyResourceActionPermission: mockVerifyResourceActionPermission,
+        });
+        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: {} }];
+        mockGetApp.mockResolvedValue(mockApp);
+        mockGetAppResource.mockResolvedValue(mockResource);
+        mockGetAppUrl.mockResolvedValue(mockAppUrl);
+        mockGetAppMessages.mockResolvedValue(mockAppMessages);
+        mockCtx.queryParams = { view: 'view' };
+        const options = {
+            getApp: mockGetApp,
+            getAppResource: mockGetAppResource,
+            verifyResourceActionPermission: mockVerifyResourceActionPermission,
+            getAppUrl: mockGetAppUrl,
+            getAppMessages: mockGetAppMessages,
+        };
+        const resourceDefinition = getResourceDefinition(mockApp, 'mockResourceType', 'view');
+        const remapperContext = await getRemapperContext(mockApp, mockApp.definition.defaultLanguage || defaultLocale, null, options, mockCtx);
+        const remappedResource = remap(resourceDefinition.views.view.remap, mockResource, remapperContext);
+        const middleware = createGetResourceById(options);
+        await middleware(mockCtx, vi.fn());
+        expect(mockCtx.body).toStrictEqual(remappedResource);
+    });
+});
+describe('createCreateResource', () => {
+    beforeEach(() => {
+        mockGetApp = vi.fn();
+        mockVerifyResourceActionPermission = vi.fn();
+        mockCreateAppResourcesWithAssets = vi.fn();
+        mockCtxIs = vi.fn();
+        mockCtx = {
+            pathParams: { appId: 1, resourceType: 'mockResourceType' },
+            user: { id: 'mockUserId', name: 'John Doe', primaryEmail: 'john@example.com' },
+            is: mockCtxIs,
+            request: {},
+        };
+    });
+    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);
+        const middleware = createCreateResource({
+            getApp: mockGetApp,
+            createAppResourcesWithAssets: mockCreateAppResourcesWithAssets,
+            verifyResourceActionPermission: mockVerifyResourceActionPermission,
+        });
+        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);
+        const middleware = createCreateResource({
+            getApp: mockGetApp,
+            createAppResourcesWithAssets: mockCreateAppResourcesWithAssets,
+            verifyResourceActionPermission: mockVerifyResourceActionPermission,
+        });
+        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/server/controllers/teams.d.ts

@@ -0,0 +1,3 @@
+import { type Middleware } from 'koa';
+import { type Options } from '../types.js';
+export declare function createGetTeams({ getApp, getAppTeams }: Options): Middleware;

package/server/controllers/teams.js

@@ -0,0 +1,12 @@
+import { notFound } from '@hapi/boom';
+export function createGetTeams({ getApp, getAppTeams }) {
+    return async (ctx) => {
+        const { pathParams: { appId }, user, } = ctx;
+        const app = await getApp({ context: ctx, query: { where: { id: appId } } });
+        if (!app) {
+            throw notFound('App not found');
+        }
+        ctx.body = await getAppTeams({ context: ctx, app, user });
+    };
+}
+//# sourceMappingURL=teams.js.map

package/server/routes/appRouter/blockAssetHandler.d.ts

@@ -0,0 +1,3 @@
+import { type Options } from '@appsemble/node-utils';
+import { type Middleware } from 'koa';
+export declare function createBlockAssetHandler({ getBlockAsset }: Options): Middleware;

package/server/routes/appRouter/blockAssetHandler.js

@@ -0,0 +1,13 @@
+import { notFound } from '@hapi/boom';
+export function createBlockAssetHandler({ getBlockAsset }) {
+    return async (ctx) => {
+        const { params: { filename, name, version }, } = ctx;
+        const blockAsset = await getBlockAsset({ filename, name, version, context: ctx });
+        if (!blockAsset) {
+            throw notFound('Block asset not found');
+        }
+        ctx.body = blockAsset.content;
+        ctx.type = blockAsset.mime;
+    };
+}
+//# sourceMappingURL=blockAssetHandler.js.map

package/server/routes/appRouter/blockCssHandler.d.ts

@@ -0,0 +1,3 @@
+import { type Options } from '@appsemble/node-utils';
+import { type Middleware } from 'koa';
+export declare function createBlockCssHandler({ getApp, getAppBlockStyles }: Options): Middleware;

package/server/routes/appRouter/blockCssHandler.js

@@ -0,0 +1,15 @@
+import { notFound } from '@hapi/boom';
+export function createBlockCssHandler({ getApp, getAppBlockStyles }) {
+    return async (ctx) => {
+        const { params: { name }, } = ctx;
+        const app = await getApp({ context: ctx });
+        if (!app) {
+            throw notFound('App not found');
+        }
+        const appBlockStyles = await getAppBlockStyles({ app, name, context: ctx });
+        const [style] = appBlockStyles;
+        ctx.body = style ? style.style : '';
+        ctx.type = 'css';
+    };
+}
+//# sourceMappingURL=blockCssHandler.js.map

package/server/routes/appRouter/bulmaHandler.d.ts

@@ -0,0 +1,3 @@
+import { type Options } from '@appsemble/node-utils';
+import { type Middleware } from 'koa';
+export declare function createBulmaHandler({ createTheme, getTheme }: Options): Middleware;