@appsemble/cli 0.20.45 → 0.21.1

package/server/options/parseQuery.js

@@ -0,0 +1,82 @@
+import { processLiteral, } from '@appsemble/node-utils';
+import { defaultParser, TokenType } from '@odata/parser';
+const operators = new Map([
+    [TokenType.EqualsExpression, 'eq'],
+    [TokenType.LesserOrEqualsExpression, 'lte'],
+    [TokenType.LesserThanExpression, 'lt'],
+    [TokenType.GreaterOrEqualsExpression, 'gte'],
+    [TokenType.GreaterThanExpression, 'gt'],
+    [TokenType.NotEqualsExpression, 'ne'],
+]);
+function renameOData(name) {
+    switch (name) {
+        case '$author':
+            return 'AuthorId';
+        case 'id':
+            return name;
+        default:
+            return name;
+    }
+}
+function processToken(token) {
+    if (token.type === TokenType.ParenExpression) {
+        return processToken(token.value);
+    }
+    if (token.type === TokenType.FirstMemberExpression) {
+        return token.raw;
+    }
+    if (operators.has(token.type)) {
+        return {
+            [processToken(token.value.left)]: {
+                [operators.get(token.type)]: processToken(token.value.right),
+            },
+        };
+    }
+    if (token.type === TokenType.Literal) {
+        return processLiteral(token);
+    }
+    throw new TypeError(`${token.position}: Unhandled OData type: ${token.type}`);
+}
+function processLogicalExpression(token) {
+    if (token.type === TokenType.BoolParenExpression || token.type === TokenType.CommonExpression) {
+        return processLogicalExpression(token.value);
+    }
+    if (token.type === TokenType.NotExpression) {
+        return { not: processLogicalExpression(token.value) };
+    }
+    const op = token.type === TokenType.AndExpression
+        ? 'and'
+        : token.type === TokenType.OrExpression
+            ? 'or'
+            : undefined;
+    if (!op) {
+        return processToken(token);
+    }
+    const flatten = (expr) => (op in expr ? expr[op] : expr);
+    const left = flatten(processLogicalExpression(token.value.left));
+    const right = flatten(processLogicalExpression(token.value.right));
+    return { [op]: [].concat(left).concat(right) };
+}
+function parseOdataFilter(query) {
+    if (!query) {
+        return {};
+    }
+    const ast = typeof query === 'string' ? defaultParser.filter(query) : query;
+    return processLogicalExpression(ast);
+}
+function parseOdataOrder(query) {
+    if (!query) {
+        return [];
+    }
+    return query.split(/,/g).map((line) => {
+        const [name, direction] = line.split(' ');
+        return [renameOData(name), direction === null || direction === void 0 ? void 0 : direction.toUpperCase()];
+    });
+}
+export function parseQuery({ $filter, $orderby }) {
+    return {
+        where: parseOdataFilter($filter),
+        order: parseOdataOrder($orderby ? $orderby.replaceAll(/(^|\B)\$author\/id(\b|$)/g, '$author') : undefined),
+    };
+}
+//# sourceMappingURL=parseQuery.js.map

package/server/options/parseQuery.test.d.ts

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

package/server/options/parseQuery.test.js

@@ -0,0 +1,43 @@
+import { parseQuery } from './parseQuery.js';
+describe('parseQuery', () => {
+    it('should parse the query correctly with valid parameters', () => {
+        const queryParams = {
+            $filter: "AuthorId eq 1 and (Title ne 'example' or Year gt 2020)",
+            $orderby: 'Title asc,Year desc',
+        };
+        const expectedParsedQuery = {
+            where: {
+                and: [
+                    { AuthorId: { eq: 1 } },
+                    {
+                        or: [{ Title: { ne: 'example' } }, { Year: { gt: 2020 } }],
+                    },
+                ],
+            },
+            order: [
+                ['Title', 'ASC'],
+                ['Year', 'DESC'],
+            ],
+        };
+        const parsedQuery = parseQuery(queryParams);
+        expect(parsedQuery).toStrictEqual(expectedParsedQuery);
+    });
+    it('should parse the query with special characters in $orderby', () => {
+        const queryParams = {
+            $filter: "Title eq 'example'",
+            $orderby: 'Title asc,$author/id desc',
+        };
+        const expectedParsedQuery = {
+            where: {
+                Title: { eq: 'example' },
+            },
+            order: [
+                ['Title', 'ASC'],
+                ['AuthorId', 'DESC'],
+            ],
+        };
+        const parsedQuery = parseQuery(queryParams);
+        expect(parsedQuery).toStrictEqual(expectedParsedQuery);
+    });
+});
+//# sourceMappingURL=parseQuery.test.js.map

package/server/options/reloadUser.d.ts

@@ -0,0 +1 @@
+export declare const reloadUser: () => Promise<Record<string, any>>;

package/server/options/reloadUser.js

@@ -0,0 +1,2 @@
+export const reloadUser = () => Promise.resolve({});
+//# sourceMappingURL=reloadUser.js.map

package/server/options/sendNotifications.d.ts

@@ -0,0 +1 @@
+export declare const sendNotifications: () => Promise<void>;

package/server/options/sendNotifications.js

@@ -0,0 +1,2 @@
+export const sendNotifications = () => Promise.resolve();
+//# sourceMappingURL=sendNotifications.js.map

package/server/options/updateAppResource.d.ts

@@ -0,0 +1,3 @@
+import { type UpdateAppResourceParams } from '@appsemble/node-utils';
+import { type Resource as ResourceInterface } from '@appsemble/types';
+export declare function updateAppResource({ id, resource, type, }: UpdateAppResourceParams): Promise<ResourceInterface | null>;

package/server/options/updateAppResource.js

@@ -0,0 +1,5 @@
+import { Resource } from '../models/Resource.js';
+export function updateAppResource({ id, resource, type, }) {
+    return Resource.updateOne(id, resource, type);
+}
+//# sourceMappingURL=updateAppResource.js.map

package/server/options/verifyResourceActionPermission.d.ts

@@ -0,0 +1 @@
+export declare const verifyResourceActionPermission: () => Promise<Record<string, any>>;

package/server/options/verifyResourceActionPermission.js

@@ -0,0 +1,2 @@
+export const verifyResourceActionPermission = () => Promise.resolve({});
+//# sourceMappingURL=verifyResourceActionPermission.js.map

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

@@ -0,0 +1,2 @@
+import { type Middleware } from 'koa';
+export declare const appRouter: Middleware;

package/server/routes/appRouter/index.js

@@ -0,0 +1,4 @@
+import { createAppRouter } from '@appsemble/node-utils';
+import { options } from '../../options/options.js';
+export const appRouter = createAppRouter(options);
+//# sourceMappingURL=index.js.map

package/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vitest/dist/config.js").UserProjectConfigExport;
+export default _default;

package/vitest.setup.d.ts

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

package/{jest.setup.js → vitest.setup.js}

@@ -1,4 +1,4 @@
 import { setFixtureBase, setLogLevel } from '@appsemble/node-utils';
 setFixtureBase(import.meta);
 setLogLevel(0);
-//# sourceMappingURL=jest.setup.js.map
+//# sourceMappingURL=vitest.setup.js.map