@appsemble/utils 0.24.0 → 0.24.2

package/README.md

@@ -1,9 +1,9 @@
-# ![](https://gitlab.com/appsemble/appsemble/-/raw/0.24.0/config/assets/logo.svg) Appsemble Utilities
+# ![](https://gitlab.com/appsemble/appsemble/-/raw/0.24.2/config/assets/logo.svg) Appsemble Utilities
 
 > Internal utility functions used across multiple Appsemble projects.
 
 [![npm](https://img.shields.io/npm/v/@appsemble/utils)](https://www.npmjs.com/package/@appsemble/utils)
-[![GitLab CI](https://gitlab.com/appsemble/appsemble/badges/0.24.0/pipeline.svg)](https://gitlab.com/appsemble/appsemble/-/releases/0.24.0)
+[![GitLab CI](https://gitlab.com/appsemble/appsemble/badges/0.24.2/pipeline.svg)](https://gitlab.com/appsemble/appsemble/-/releases/0.24.2)
 [![Prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg)](https://prettier.io)
 
 ## Table of Contents
@@ -26,5 +26,5 @@ not guaranteed.
 
 ## License
 
-[LGPL-3.0-only](https://gitlab.com/appsemble/appsemble/-/blob/0.24.0/LICENSE.md) ©
+[LGPL-3.0-only](https://gitlab.com/appsemble/appsemble/-/blob/0.24.2/LICENSE.md) ©
 [Appsemble](https://appsemble.com)

package/api/components/schemas/AppDefinition.js

@@ -68,6 +68,9 @@ This **must** match the name of a page defined for the app.
         controller: {
             $ref: '#/components/schemas/ControllerDefinition',
         },
+        users: {
+            $ref: '#/components/schemas/UsersDefinition',
+        },
         resources: {
             type: 'object',
             description: `Resources define how Appsemble can store data for an app.

package/api/components/schemas/Resource.js

@@ -10,9 +10,21 @@ export const Resource = {
         $clonable: {
             type: 'boolean',
         },
+        $ephemeral: {
+            type: 'boolean',
+        },
         $expires: {
-            type: 'string',
-            format: 'date-time',
+            anyOf: [
+                {
+                    type: 'string',
+                    format: 'date-time',
+                },
+                {
+                    type: 'string',
+                    pattern: /^(\d+(y|yr|years))?\s*(\d+months)?\s*(\d+(w|wk|weeks))?\s*(\d+(d|days))?\s*(\d+(h|hr|hours))?\s*(\d+(m|min|minutes))?\s*(\d+(s|sec|seconds))?$/
+                        .source,
+                },
+            ],
         },
     },
 };

package/api/components/schemas/ResourceDefinition.js

@@ -62,6 +62,14 @@ Example: 1d 8h 30m
             pattern: /^(\d+(y|yr|years))?\s*(\d+months)?\s*(\d+(w|wk|weeks))?\s*(\d+(d|days))?\s*(\d+(h|hr|hours))?\s*(\d+(m|min|minutes))?\s*(\d+(s|sec|seconds))?$/
                 .source,
         },
+        clonable: {
+            type: 'boolean',
+            description: 'Whether the resource should be able to be transferred when cloning the app it belongs to',
+        },
+        ephemeral: {
+            type: 'boolean',
+            description: 'Whether the resource should be cleaned up regularly.',
+        },
         schema: {
             $ref: '#/components/schemas/JSONSchemaRoot',
             description: 'JSON schema definitions that may be used by the app.',

package/api/components/schemas/UserCreateActionDefinition.js

@@ -23,7 +23,7 @@ Does nothing if the user is already logged in.`,
         properties: {
             description: `The custom properties for the user.
 
-Every value will be converted to a string.`,
+Values will be validated based on \`user.properties\`, if defined in the app definition.`,
         },
         role: {
             description: "The role for the created account. Defaults to the default role in the app's security definition.",

package/api/components/schemas/UserPropertyDefinition.d.ts

@@ -0,0 +1,2 @@
+import { type OpenAPIV3 } from 'openapi-types';
+export declare const UserPropertyDefinition: OpenAPIV3.NonArraySchemaObject;

package/api/components/schemas/UserPropertyDefinition.js

@@ -0,0 +1,47 @@
+export const UserPropertyDefinition = {
+    anyOf: [
+        {
+            type: 'object',
+            description: 'Definition for a user property.',
+            required: ['schema'],
+            additionalProperties: false,
+            properties: {
+                schema: {
+                    anyOf: [
+                        { $ref: '#/components/schemas/JSONSchemaInteger' },
+                        { $ref: '#/components/schemas/JSONSchemaArray' },
+                    ],
+                },
+                reference: {
+                    type: 'object',
+                    additionalProperties: false,
+                    description: 'The object for the reference to another resource',
+                    properties: {
+                        resource: {
+                            type: 'string',
+                            description: 'The resource referenced by this user property.',
+                        },
+                    },
+                },
+            },
+        },
+        {
+            type: 'object',
+            description: 'Definition for a user property.',
+            required: ['schema'],
+            additionalProperties: false,
+            properties: {
+                schema: {
+                    anyOf: [
+                        { $ref: '#/components/schemas/JSONSchemaString' },
+                        { $ref: '#/components/schemas/JSONSchemaNumber' },
+                        { $ref: '#/components/schemas/JSONSchemaEnum' },
+                        { $ref: '#/components/schemas/JSONSchemaBoolean' },
+                        { $ref: '#/components/schemas/JSONSchemaObject' },
+                    ],
+                },
+            },
+        },
+    ],
+};
+//# sourceMappingURL=UserPropertyDefinition.js.map

package/api/components/schemas/UserRegisterActionDefinition.js

@@ -26,7 +26,7 @@ Does nothing if the user is already logged in.`,
         properties: {
             description: `The custom properties for the user.
 
-Every value will be converted to a string.`,
+Values will be validated based on \`user.properties\`, if defined in the app definition.`,
         },
         login: {
             description: 'Whether to login after registering.',

package/api/components/schemas/UserUpdateActionDefinition.js

@@ -26,7 +26,7 @@ Does nothing if the user isn’t logged in.`,
         properties: {
             description: `The custom properties for the user.
 
-Every value will be converted to a string.`,
+Values will be validated based on \`user.properties\`, if defined in the app definition.`,
         },
         role: {
             description: "The role for the updated account. Defaults to the default role in the app's security definition.",

package/api/components/schemas/UsersDefinition.d.ts

@@ -0,0 +1,2 @@
+import { type OpenAPIV3 } from 'openapi-types';
+export declare const UsersDefinition: OpenAPIV3.NonArraySchemaObject;

package/api/components/schemas/UsersDefinition.js

@@ -0,0 +1,17 @@
+export const UsersDefinition = {
+    type: 'object',
+    description: 'Definition for user properties.',
+    required: [],
+    additionalProperties: false,
+    properties: {
+        properties: {
+            type: 'object',
+            description: 'The properties object configuring users in the app',
+            additionalProperties: {
+                description: 'A single user property definition.',
+                $ref: '#/components/schemas/UserPropertyDefinition',
+            },
+        },
+    },
+};
+//# sourceMappingURL=UsersDefinition.js.map

package/api/components/schemas/index.d.ts

@@ -127,3 +127,5 @@ export * from './UserQueryActionDefinition.js';
 export * from './UserRemoveActionDefinition.js';
 export * from './LoopPageDefinition.js';
 export * from './LoopPageActionsDefinition.js';
+export * from './UsersDefinition.js';
+export * from './UserPropertyDefinition.js';

package/api/components/schemas/index.js

@@ -127,4 +127,6 @@ export * from './UserQueryActionDefinition.js';
 export * from './UserRemoveActionDefinition.js';
 export * from './LoopPageDefinition.js';
 export * from './LoopPageActionsDefinition.js';
+export * from './UsersDefinition.js';
+export * from './UserPropertyDefinition.js';
 //# sourceMappingURL=index.js.map

package/api/paths/apps.js

@@ -1477,5 +1477,16 @@ This will return a 404 if the user has not uploaded one.`,
             security: [{ app: ['teams:read'] }],
         },
     },
+    '/api/apps/{appId}/reseed': {
+        parameters: [{ $ref: '#/components/parameters/appId' }],
+        post: {
+            tags: ['app'],
+            operationId: 'reseedDemoApp',
+            responses: {
+                200: { description: 'The app has successfully been reseeded.' },
+            },
+            security: [{ studio: ['apps:write'] }],
+        },
+    },
 };
 //# sourceMappingURL=apps.js.map

package/api/paths/assets.js

@@ -44,6 +44,10 @@ export const paths = {
                                     pattern: normalized.source,
                                     description: 'The given name of the asset. Assets may be referenced by their name or ID in the API.',
                                 },
+                                clonable: {
+                                    type: 'boolean',
+                                    description: 'Whether the asset should be transferable when cloning the app they are in.',
+                                },
                             },
                         },
                     },

package/api/paths/templates.js

@@ -64,6 +64,10 @@ export const paths = {
                                     type: 'boolean',
                                     description: 'Include example resources.',
                                 },
+                                assets: {
+                                    type: 'boolean',
+                                    description: 'Include example assets.',
+                                },
                                 visibility: {
                                     $ref: '#/components/schemas/App/properties/visibility',
                                 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appsemble/utils",
-  "version": "0.24.0",
+  "version": "0.24.2",
   "description": "Utility functions used in Appsemble internally",
   "keywords": [
     "app",
@@ -37,7 +37,7 @@
     "test": "vitest"
   },
   "dependencies": {
-    "@appsemble/types": "0.24.0",
+    "@appsemble/types": "0.24.2",
     "axios": "^1.0.0",
     "cron-parser": "^4.0.0",
     "date-fns": "^2.0.0",

package/validation.js

@@ -34,6 +34,37 @@ function validateJSONSchema(schema, prefix, report) {
         }
     }
 }
+function validateUsersSchema(definition, report) {
+    var _a;
+    if (!definition.users) {
+        return;
+    }
+    for (const [propertyName, propertyDefinition] of Object.entries(definition.users.properties)) {
+        // Handled by schema validation
+        if (!(propertyDefinition === null || propertyDefinition === void 0 ? void 0 : propertyDefinition.schema)) {
+            continue;
+        }
+        const { schema } = propertyDefinition;
+        const prefix = ['users', 'properties', propertyName, 'schema'];
+        validateJSONSchema(schema, prefix, report);
+        if (!('type' in schema) && !('enum' in schema)) {
+            report(schema, 'must define type or enum', prefix);
+        }
+        if ('reference' in propertyDefinition) {
+            const { resource: resourceName } = propertyDefinition.reference;
+            const resourceDefinition = (_a = definition.resources) === null || _a === void 0 ? void 0 : _a[resourceName];
+            if (!resourceDefinition) {
+                report(resourceName, 'refers to a resource that doesn’t exist', [
+                    'users',
+                    'properties',
+                    propertyName,
+                    'reference',
+                    resourceName,
+                ]);
+            }
+        }
+    }
+}
 function validateResourceSchemas(definition, report) {
     if (!definition.resources) {
         return;
@@ -447,7 +478,7 @@ function validateActions(definition, report) {
     const urlRegex = new RegExp(`^${partialNormalized.source}:`);
     iterApp(definition, {
         onAction(action, path) {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
             if (path[0] === 'cron' && !serverActions.has(action.type)) {
                 report(action.type, 'action type is not supported for cron jobs', [...path, 'type']);
                 return;
@@ -456,17 +487,29 @@ function validateActions(definition, report) {
                 report(action.type, 'refers to a user action but the app doesn’t have a security definition', [...path, 'type']);
                 return;
             }
+            if (['user.register', 'user.create', 'user.update'].includes(action.type) &&
+                Object.values(action.properties)[0] &&
+                ((_a = definition.users) === null || _a === void 0 ? void 0 : _a.properties)) {
+                for (const propertyName of Object.keys(Object.values(action.properties)[0])) {
+                    if (!((_b = definition.users) === null || _b === void 0 ? void 0 : _b.properties[propertyName])) {
+                        report(action.type, 'contains a property that doesn’t exist in users.properties', [
+                            ...path,
+                            'properties',
+                        ]);
+                    }
+                }
+            }
             if (action.type.startsWith('resource.')) {
                 // All of the actions starting with `resource.` contain a property called `resource`.
                 const { resource: resourceName, view } = action;
-                const resource = (_a = definition.resources) === null || _a === void 0 ? void 0 : _a[resourceName];
+                const resource = (_c = definition.resources) === null || _c === void 0 ? void 0 : _c[resourceName];
                 if (!resource) {
                     report(action.type, 'refers to a resource that doesn’t exist', [...path, 'resource']);
                     return;
                 }
                 if (!action.type.startsWith('resource.subscription.')) {
                     const type = action.type.split('.')[1];
-                    const roles = (_c = (_b = resource === null || resource === void 0 ? void 0 : resource[type]) === null || _b === void 0 ? void 0 : _b.roles) !== null && _c !== void 0 ? _c : resource === null || resource === void 0 ? void 0 : resource.roles;
+                    const roles = (_e = (_d = resource === null || resource === void 0 ? void 0 : resource[type]) === null || _d === void 0 ? void 0 : _d.roles) !== null && _e !== void 0 ? _e : resource === null || resource === void 0 ? void 0 : resource.roles;
                     if (!roles) {
                         report(action.type, 'refers to a resource action that is currently set to private', [
                             ...path,
@@ -479,11 +522,11 @@ function validateActions(definition, report) {
                         return;
                     }
                     if ((type === 'get' || type === 'query') && view) {
-                        if (!((_d = resource.views) === null || _d === void 0 ? void 0 : _d[view])) {
+                        if (!((_f = resource.views) === null || _f === void 0 ? void 0 : _f[view])) {
                             report(action.type, 'refers to a view that doesn’t exist', [...path, 'view']);
                             return;
                         }
-                        const viewRoles = (_e = resource === null || resource === void 0 ? void 0 : resource.views) === null || _e === void 0 ? void 0 : _e[view].roles;
+                        const viewRoles = (_g = resource === null || resource === void 0 ? void 0 : resource.views) === null || _g === void 0 ? void 0 : _g[view].roles;
                         if (!(viewRoles === null || viewRoles === void 0 ? void 0 : viewRoles.length)) {
                             report(action.type, 'refers to a resource view that is currently set to private', [
                                 ...path,
@@ -499,19 +542,19 @@ function validateActions(definition, report) {
                 }
             }
             if (action.type.startsWith('flow.')) {
-                const page = (_f = definition.pages) === null || _f === void 0 ? void 0 : _f[Number(path[1])];
+                const page = (_h = definition.pages) === null || _h === void 0 ? void 0 : _h[Number(path[1])];
                 if (page.type !== 'flow' && page.type !== 'loop') {
                     report(action.type, 'flow actions can only be used on pages with the type ‘flow’ or ‘loop’', [...path, 'type']);
                     return;
                 }
-                if (action.type === 'flow.cancel' && !((_g = page.actions) === null || _g === void 0 ? void 0 : _g.onFlowCancel)) {
+                if (action.type === 'flow.cancel' && !((_j = page.actions) === null || _j === void 0 ? void 0 : _j.onFlowCancel)) {
                     report(action.type, 'was defined but ‘onFlowCancel’ page action wasn’t defined', [
                         ...path,
                         'type',
                     ]);
                     return;
                 }
-                if (action.type === 'flow.finish' && !((_h = page.actions) === null || _h === void 0 ? void 0 : _h.onFlowFinish)) {
+                if (action.type === 'flow.finish' && !((_k = page.actions) === null || _k === void 0 ? void 0 : _k.onFlowFinish)) {
                     report(action.type, 'was defined but ‘onFlowFinish’ page action wasn’t defined', [
                         ...path,
                         'type',
@@ -525,7 +568,7 @@ function validateActions(definition, report) {
                 if (page.type === 'flow' &&
                     action.type === 'flow.next' &&
                     Number(path[3]) === page.steps.length - 1 &&
-                    !((_j = page.actions) === null || _j === void 0 ? void 0 : _j.onFlowFinish)) {
+                    !((_l = page.actions) === null || _l === void 0 ? void 0 : _l.onFlowFinish)) {
                     report(action.type, 'was defined on the last step but ‘onFlowFinish’ page action wasn’t defined', [...path, 'type']);
                     return;
                 }
@@ -756,6 +799,7 @@ export async function validateAppDefinition(definition, getBlockVersions, contro
         validateHooks(definition, report);
         validateLanguage(definition, report);
         validateResourceReferences(definition, report);
+        validateUsersSchema(definition, report);
         validateResourceSchemas(definition, report);
         validateSecurity(definition, report);
         validateBlocks(definition, blockVersionMap, report);

package/validation.test.js

@@ -935,6 +935,45 @@ describe('validateAppDefinition', () => {
             ]),
         ]);
     });
+    it('should validate user properties for type or enum', async () => {
+        const app = { ...createTestApp(), users: { properties: { foo: { schema: {} } } } };
+        const result = await validateAppDefinition(app, () => []);
+        expect(result.valid).toBe(false);
+        expect(result.errors).toStrictEqual([
+            new ValidationError('must define type or enum', {}, undefined, [
+                'users',
+                'properties',
+                'foo',
+                'schema',
+            ]),
+        ]);
+    });
+    it('should validate user properties for resource references', async () => {
+        const app = {
+            ...createTestApp(),
+            users: {
+                properties: {
+                    foo: {
+                        schema: { type: 'integer' },
+                        reference: {
+                            resource: 'tasks',
+                        },
+                    },
+                },
+            },
+        };
+        const result = await validateAppDefinition(app, () => []);
+        expect(result.valid).toBe(false);
+        expect(result.errors).toStrictEqual([
+            new ValidationError('refers to a resource that doesn’t exist', 'tasks', undefined, [
+                'users',
+                'properties',
+                'foo',
+                'reference',
+                'tasks',
+            ]),
+        ]);
+    });
     it('should validate resources use schemas define a type', async () => {
         const app = createTestApp();
         app.resources.person.schema = { properties: {} };
@@ -1689,6 +1728,147 @@ describe('validateAppDefinition', () => {
             new ValidationError('was defined but ‘onFlowCancel’ page action wasn’t defined', 'flow.cancel', undefined, ['pages', 3, 'steps', 1, 'blocks', 0, 'actions', 'onWhatever', 'type']),
         ]);
     });
+    it('should report an error if a user register action on a block adds unsupported user properties', async () => {
+        const app = {
+            ...createTestApp(),
+            users: {
+                properties: {
+                    foo: {
+                        schema: {
+                            type: 'string',
+                        },
+                    },
+                },
+            },
+        };
+        app.pages[0].blocks.push({
+            type: 'test',
+            version: '1.2.3',
+            actions: {
+                onWhatever: {
+                    type: 'user.register',
+                    displayName: 'name',
+                    email: 'email@example.com',
+                    password: 'password',
+                    properties: {
+                        'object.from': {
+                            bar: 'baz',
+                        },
+                    },
+                },
+            },
+        });
+        const result = await validateAppDefinition(app, () => [
+            {
+                name: '@appsemble/test',
+                version: '1.2.3',
+                files: [],
+                languages: [],
+                actions: {
+                    onWhatever: {},
+                },
+            },
+        ]);
+        expect(result.valid).toBe(false);
+        expect(result.errors).toStrictEqual([
+            new ValidationError('contains a property that doesn’t exist in users.properties', 'user.register', undefined, ['pages', 0, 'blocks', 0, 'actions', 'onWhatever', 'properties']),
+        ]);
+    });
+    it('should report an error if a user create action on a block adds unsupported user properties', async () => {
+        const app = {
+            ...createTestApp(),
+            users: {
+                properties: {
+                    foo: {
+                        schema: {
+                            type: 'string',
+                        },
+                    },
+                },
+            },
+        };
+        app.pages[0].blocks.push({
+            type: 'test',
+            version: '1.2.3',
+            actions: {
+                onWhatever: {
+                    type: 'user.create',
+                    name: 'name',
+                    email: 'email@example.com',
+                    password: 'password',
+                    role: 'role',
+                    properties: {
+                        'object.from': {
+                            bar: 'baz',
+                        },
+                    },
+                },
+            },
+        });
+        const result = await validateAppDefinition(app, () => [
+            {
+                name: '@appsemble/test',
+                version: '1.2.3',
+                files: [],
+                languages: [],
+                actions: {
+                    onWhatever: {},
+                },
+            },
+        ]);
+        expect(result.valid).toBe(false);
+        expect(result.errors).toStrictEqual([
+            new ValidationError('contains a property that doesn’t exist in users.properties', 'user.create', undefined, ['pages', 0, 'blocks', 0, 'actions', 'onWhatever', 'properties']),
+        ]);
+    });
+    it('should report an error if a user update action on a block adds unsupported user properties', async () => {
+        const app = {
+            ...createTestApp(),
+            users: {
+                properties: {
+                    foo: {
+                        schema: {
+                            type: 'string',
+                        },
+                    },
+                },
+            },
+        };
+        app.pages[0].blocks.push({
+            type: 'test',
+            version: '1.2.3',
+            actions: {
+                onWhatever: {
+                    type: 'user.update',
+                    name: 'name',
+                    currentEmail: 'email@example.com',
+                    newEmail: 'new-email@example.com',
+                    password: 'password',
+                    role: 'role',
+                    properties: {
+                        'object.from': {
+                            bar: 'baz',
+                        },
+                    },
+                },
+            },
+        });
+        const result = await validateAppDefinition(app, () => [
+            {
+                name: '@appsemble/test',
+                version: '1.2.3',
+                files: [],
+                languages: [],
+                actions: {
+                    onWhatever: {},
+                },
+            },
+        ]);
+        expect(result.valid).toBe(false);
+        expect(result.errors).toStrictEqual([
+            new ValidationError('contains a property that doesn’t exist in users.properties', 'user.update', undefined, ['pages', 0, 'blocks', 0, 'actions', 'onWhatever', 'properties']),
+        ]);
+    });
     it('should report an error if a resource action on a block refers to a non-existent resource', async () => {
         const app = createTestApp();
         app.pages[0].blocks.push({