@appsemble/node-utils 0.26.0 → 0.27.0

package/README.md

@@ -1,9 +1,9 @@
-# ![](https://gitlab.com/appsemble/appsemble/-/raw/0.26.0/config/assets/logo.svg) Appsemble Node Utilities
+# ![](https://gitlab.com/appsemble/appsemble/-/raw/0.27.0/config/assets/logo.svg) Appsemble Node Utilities
 
 > NodeJS utilities used by Appsemble internally.
 
 [![npm](https://img.shields.io/npm/v/@appsemble/node-utils)](https://www.npmjs.com/package/@appsemble/node-utils)
-[![GitLab CI](https://gitlab.com/appsemble/appsemble/badges/0.26.0/pipeline.svg)](https://gitlab.com/appsemble/appsemble/-/releases/0.26.0)
+[![GitLab CI](https://gitlab.com/appsemble/appsemble/badges/0.27.0/pipeline.svg)](https://gitlab.com/appsemble/appsemble/-/releases/0.27.0)
 [![Prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg)](https://prettier.io)
 
 ## Table of Contents
@@ -26,5 +26,5 @@ compatibility is not guaranteed.
 
 ## License
 
-[LGPL-3.0-only](https://gitlab.com/appsemble/appsemble/-/blob/0.26.0/LICENSE.md) ©
+[LGPL-3.0-only](https://gitlab.com/appsemble/appsemble/-/blob/0.27.0/LICENSE.md) ©
 [Appsemble](https://appsemble.com)

package/app.d.ts

@@ -15,3 +15,4 @@ import { type Options } from './server/types.js';
  * @returns A localized remapper context for the app.
  */
 export declare function getRemapperContext(app: App, language: string, userInfo: UserInfo, options: Options, context: ParameterizedContext<DefaultState, DefaultContext, any>): Promise<RemapperContext>;
+export declare function applyAppVariant(appPath: string, appVariant: string): Promise<void>;

package/app.js

@@ -1,6 +1,16 @@
+import { existsSync } from 'node:fs';
+import { readFile, rm, writeFile } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
 import { defaultLocale, has, objectCache } from '@appsemble/utils';
 import { memoize } from '@formatjs/fast-memoize';
+import { generate, parse, walk } from 'css-tree';
+import { copy, ensureDir } from 'fs-extra';
 import { IntlMessageFormat } from 'intl-messageformat';
+import lodash from 'lodash';
+import { format, resolveConfig } from 'prettier';
+import { parseDocument } from 'yaml';
+import { readData, writeData } from './fs.js';
+import { logger } from './logger.js';
 const getNumberFormat = memoize((locale, opts) => new Intl.NumberFormat(locale, opts));
 const getPluralRules = memoize((locale, opts) => new Intl.PluralRules(locale, opts));
 /**
@@ -47,4 +57,175 @@ export async function getRemapperContext(app, language, userInfo, options, conte
         locale: (_b = (_a = userInfo === null || userInfo === void 0 ? void 0 : userInfo.locale) !== null && _a !== void 0 ? _a : app.definition.defaultLanguage) !== null && _b !== void 0 ? _b : defaultLocale,
     };
 }
+function replaceStyle(stylesheet, selector, property, value) {
+    try {
+        walk(stylesheet, (nodeSelector) => {
+            if (nodeSelector.type !== 'Rule' || nodeSelector.prelude.type !== 'Raw') {
+                return;
+            }
+            if (nodeSelector.prelude.value === selector) {
+                walk(nodeSelector, (declaration) => {
+                    if (declaration.type !== 'Declaration' || declaration.value.type !== 'Raw') {
+                        return;
+                    }
+                    if (declaration.property === property) {
+                        // eslint-disable-next-line no-param-reassign
+                        declaration.value.value = value;
+                    }
+                });
+            }
+        });
+        return stylesheet;
+    }
+    catch (error) {
+        logger.error(error);
+    }
+}
+/**
+ * Patch an app definition of an app inside the `apps` folder.
+ *
+ * @param appPath The path to the app to patch.
+ * @param patches Patches to apply to the YAML.
+ */
+async function patchDefinition(appPath, patches) {
+    try {
+        const path = join(appPath, 'app-definition.yaml');
+        logger.verbose(`Updating ${path}`);
+        const yaml = await readFile(path, 'utf8');
+        const doc = parseDocument(yaml);
+        for (const [key, value] of patches) {
+            if (value === undefined) {
+                doc.deleteIn(key);
+            }
+            else {
+                doc.setIn(key, value);
+            }
+        }
+        const prettierOptions = (await resolveConfig(path, { editorconfig: true }));
+        prettierOptions.parser = 'yaml';
+        await writeFile(path, await format(String(doc), prettierOptions));
+        logger.verbose(`Successfully updated ${path}`);
+    }
+    catch (error) {
+        logger.error(error);
+    }
+}
+/**
+ * Patch app messages.
+ *
+ * The replacements will be deep merged into the original content.
+ *
+ * @param appPath The name of the app to patch.
+ * @param replacements Replacements for the original messages.
+ */
+async function patchMessages(appPath, replacements) {
+    try {
+        const i18nPath = join(appPath, 'i18n');
+        for (const [language, replacementMessages] of Object.entries(replacements)) {
+            const originalMessagesPath = join(i18nPath, `${language}.json`);
+            logger.verbose(`Updating ${originalMessagesPath}`);
+            const [originalMessages] = await readData(originalMessagesPath);
+            await (replacementMessages
+                ? writeData(originalMessagesPath, lodash.merge(originalMessages, replacementMessages))
+                : rm(originalMessagesPath));
+            logger.verbose(`Successfully updated ${originalMessagesPath}`);
+        }
+    }
+    catch (error) {
+        logger.error(error);
+    }
+}
+async function patchStyle(replacementsPath, replacements) {
+    try {
+        logger.verbose(`Updating ${replacementsPath}`);
+        const cssFile = await readFile(replacementsPath, 'utf8');
+        let doc = parse(cssFile, {
+            parseAtrulePrelude: false,
+            parseRulePrelude: false,
+            parseValue: false,
+        });
+        for (const { property, selector, value } of replacements) {
+            doc = replaceStyle(doc, selector, property, String(value));
+        }
+        await writeFile(replacementsPath, generate(doc));
+        logger.verbose(`Successfully updated ${replacementsPath}`);
+    }
+    catch (error) {
+        logger.error(error);
+    }
+}
+/**
+ * Patch the app's styles.
+ *
+ * @param appPath The path to the app to patch.
+ * @param replacements Replacements for the original style.
+ */
+async function patchStyles(appPath, replacements) {
+    try {
+        const themePath = join(appPath, 'theme');
+        // Style type can be @appsemble, shared or core
+        for (const [styleType, replacementsByStyleType] of Object.entries(replacements)) {
+            const styleTypePath = join(themePath, styleType);
+            // FileOrBlock name can either be the name of a css file or the name of an appsemble block
+            for (const [fileOrBlockName, replacementsByFileOrBlock] of Object.entries(replacementsByStyleType)) {
+                const fileOrBlockPath = join(styleTypePath, fileOrBlockName);
+                if (Array.isArray(replacementsByFileOrBlock)) {
+                    await patchStyle(fileOrBlockPath, replacementsByFileOrBlock);
+                }
+                else {
+                    for (const [blockFilename, replacementsByFile] of Object.entries(replacementsByFileOrBlock)) {
+                        const blockFilePath = join(fileOrBlockPath, blockFilename);
+                        await patchStyle(blockFilePath, replacementsByFile);
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        logger.error(error);
+    }
+}
+async function transferAppVariantFiles(appPath, appVariantDefDir, appVariantDestDir, pathToCopy) {
+    try {
+        const defPathToCopy = join(appVariantDefDir, pathToCopy);
+        if (existsSync(defPathToCopy)) {
+            const existingPath = join(appVariantDestDir, pathToCopy);
+            if (existsSync(existingPath)) {
+                await rm(existingPath, { recursive: true });
+            }
+            await copy(defPathToCopy, join(appVariantDestDir, pathToCopy));
+            logger.verbose(`Successfully copied ${pathToCopy} to ${appVariantDestDir}`);
+        }
+    }
+    catch (error) {
+        logger.error(error);
+    }
+}
+export async function applyAppVariant(appPath, appVariant) {
+    try {
+        logger.info(`Applying ${appVariant} variant to ${appPath}`);
+        const appVariantDestDir = join(dirname(appPath), `${basename(appPath)}-${appVariant}`);
+        await ensureDir(appVariantDestDir);
+        logger.verbose(`Successfully created ${appVariantDestDir}`);
+        await copy(appPath, appVariantDestDir);
+        logger.verbose(`Successfully copied app files to ${appVariantDestDir}`);
+        const appVariantDefDir = join(appPath, 'variants', appVariant);
+        await transferAppVariantFiles(appPath, appVariantDefDir, appVariantDestDir, 'assets');
+        await transferAppVariantFiles(appPath, appVariantDefDir, appVariantDestDir, 'resources');
+        await transferAppVariantFiles(appPath, appVariantDefDir, appVariantDestDir, 'screenshots');
+        await transferAppVariantFiles(appPath, appVariantDefDir, appVariantDestDir, 'icon.png');
+        const patchesPath = join(appVariantDefDir, 'patches');
+        const [definitionPatches] = await readData(join(patchesPath, 'app-definition.json'));
+        await patchDefinition(appVariantDestDir, definitionPatches);
+        const [messagesPatches] = await readData(join(patchesPath, 'messages.json'));
+        await patchMessages(appVariantDestDir, messagesPatches);
+        const [stylesPatches] = await readData(join(patchesPath, 'styles.json'));
+        await patchStyles(appVariantDestDir, stylesPatches);
+        logger.info(`Successfully applied ${appVariant} variant to ${appPath}`);
+        logger.verbose(`The ${appVariant} variant app can be found in ${appVariantDestDir}`);
+    }
+    catch (error) {
+        logger.error(error);
+    }
+}
 //# sourceMappingURL=app.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appsemble/node-utils",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "description": "NodeJS utilities used by Appsemble internally.",
   "keywords": [
     "app",
@@ -38,8 +38,8 @@
     "test": "vitest"
   },
   "dependencies": {
-    "@appsemble/types": "0.26.0",
-    "@appsemble/utils": "0.26.0",
+    "@appsemble/types": "0.27.0",
+    "@appsemble/utils": "0.27.0",
     "@formatjs/fast-memoize": "^2.0.0",
     "@fortawesome/fontawesome-free": "^6.0.0",
     "@koa/cors": "^4.0.0",
@@ -52,13 +52,17 @@
     "bulma-switch": "^2.0.0",
     "chalk": "^5.0.0",
     "cli-highlight": "^2.0.0",
+    "css-tree": "^2.0.0",
     "csv-parse": "^5.0.0",
     "date-fns": "^2.0.0",
     "express-to-koa": "^2.0.0",
     "fast-glob": "^3.0.0",
     "form-data": "^4.0.0",
+    "fs-extra": "^11.0.0",
+    "inquirer": "^9.0.0",
     "intl-messageformat": "^10.0.0",
     "jsonschema": "^1.0.0",
+    "keytar": "^7.0.0",
     "koa": "^2.0.0",
     "koa-compose": "^4.0.0",
     "koa-compress": "^5.0.0",
@@ -74,6 +78,7 @@
     "koas-status-code": "^0.7.0",
     "koas-swagger-ui": "^0.7.0",
     "language-tags": "^1.0.0",
+    "lodash": "^4.0.0",
     "lodash-es": "^4.0.0",
     "logform": "^2.0.0",
     "mime-types": "^2.0.0",
@@ -88,12 +93,11 @@
     "webpack": "^5.0.0",
     "webpack-dev-middleware": "^6.0.0",
     "winston": "^3.0.0",
-    "keytar": "^7.0.0",
-    "inquirer": "^9.0.0",
     "yaml": "^2.0.0",
     "yargs": "^17.0.0"
   },
   "devDependencies": {
+    "@types/css-tree": "^2.0.0",
     "@types/koa-compress": "^4.0.0",
     "@types/koa-range": "^0.3.0",
     "axios-mock-adapter": "^1.0.0",

package/resource.js

@@ -146,7 +146,6 @@ export function processResourceBody(ctx, definition, knownAssetIds = [], knownEx
                 ],
             },
             $clonable: { type: 'boolean' },
-            $ephemeral: { type: 'boolean' },
             ...Object.fromEntries(Object.values((_a = definition.references) !== null && _a !== void 0 ? _a : {}).map((reference) => [
                 `$${reference.resource}`,
                 { type: 'integer' },

package/server/controllers/resources.d.ts

@@ -6,3 +6,5 @@ export declare function createGetResourceById(options: Options): Middleware;
 export declare function createCreateResource(options: Options): Middleware;
 export declare function createUpdateResource(options: Options): Middleware;
 export declare function createDeleteResource(options: Options): Middleware;
+export declare function createSeedResource(options: Options): Middleware;
+export declare function createDeleteSeedResources(options: Options): Middleware;

package/server/controllers/resources.js

@@ -159,10 +159,9 @@ export function createGetResourceById(options) {
 export function createCreateResource(options) {
     return async (ctx) => {
         const { pathParams: { appId, resourceType }, } = ctx;
-        const { checkSeededResources, createAppResourcesWithAssets, getApp, getAppAssets, verifyResourceActionPermission, } = options;
+        const { createAppResourcesWithAssets, getApp, getAppAssets, verifyResourceActionPermission } = options;
         const action = 'create';
         const app = await getApp({ context: ctx, query: { where: { id: appId } } });
-        const resourceSeeded = await checkSeededResources({ context: ctx, app, resourceType });
         const resourceDefinition = getResourceDefinition(app, resourceType, ctx);
         await verifyResourceActionPermission({ app, context: ctx, action, resourceType, options, ctx });
         const appAssets = await getAppAssets({ app, context: ctx });
@@ -172,78 +171,19 @@ export function createCreateResource(options) {
             return;
         }
         const resources = Array.isArray(processedBody) ? processedBody : [processedBody];
-        let createdResources;
-        // In demo apps, there are two types of resources.
-        // If the app has not been seeded, resources passed from the request body
-        // are interpreted as seed resources and created with "seed: true". In addition,
-        // copies of these resources are created with "ephemeral: true".
-        // If the app has already been seeded, only new ephemeral resources are created,
-        // processed from the request body.
-        if (app.demoMode) {
-            if (!resourceSeeded && app.seed) {
-                const preparedSeedAssets = structuredClone(preparedAssets);
-                const preparedSeedResources = resources.map((resource) => {
-                    var _a;
-                    const cleanResource = { ...resource };
-                    for (const referencedProperty of Object.keys((_a = resourceDefinition.references) !== null && _a !== void 0 ? _a : {})) {
-                        delete cleanResource[referencedProperty];
-                    }
-                    return {
-                        ...cleanResource,
-                        $seed: true,
-                        $ephemeral: false,
-                    };
-                });
-                for (const preparedSeedAsset of preparedSeedAssets) {
-                    const index = resources.findIndex(({ $clonable: clonable, $ephemeral: ephemeral, $seed: seed, ...cleanResource }) => {
-                        const { $clonable, $ephemeral, $seed, ...cleanAssetResource } = preparedSeedAsset.resource;
-                        return isDeepStrictEqual(cleanResource, cleanAssetResource);
-                    });
-                    const previousAssetId = preparedSeedAsset.id;
-                    const newAssetId = randomUUID();
-                    const updatedResource = JSON.parse(JSON.stringify(preparedSeedResources[index]).replace(previousAssetId, newAssetId));
-                    preparedSeedAsset.id = newAssetId;
-                    preparedSeedAsset.resource = updatedResource;
-                    preparedSeedResources[index] = updatedResource;
-                }
-                await createAppResourcesWithAssets({
-                    app,
-                    context: ctx,
-                    resources: preparedSeedResources,
-                    preparedAssets: preparedSeedAssets,
-                    resourceType,
-                    action,
-                    options,
-                });
-            }
-            createdResources = await createAppResourcesWithAssets({
-                app,
-                context: ctx,
-                resources: resources.map((resource) => ({
-                    ...resource,
-                    $seed: false,
-                    $ephemeral: true,
-                    $clonable: false,
-                })),
-                preparedAssets,
-                resourceType,
-                action,
-                options,
-            });
-        }
-        else {
-            // In regular apps, resources are created as usual
-            // with "clonable", "ephemeral" and "expires" passed from the request body
-            createdResources = await createAppResourcesWithAssets({
-                app,
-                context: ctx,
-                resources,
-                preparedAssets,
-                resourceType,
-                action,
-                options,
-            });
-        }
+        const createdResources = await createAppResourcesWithAssets({
+            app,
+            context: ctx,
+            resources: resources.map((resource) => ({
+                ...resource,
+                $seed: false,
+                $ephemeral: app.demoMode,
+            })),
+            preparedAssets,
+            resourceType,
+            action,
+            options,
+        });
         ctx.body = Array.isArray(processedBody) ? createdResources : createdResources[0];
     };
 }
@@ -337,10 +277,112 @@ export function createDeleteResource(options) {
             context: ctx,
             id: resourceId,
             type: resourceType,
-            action,
             options,
         });
         ctx.status = 204;
     };
 }
+export function createSeedResource(options) {
+    return async (ctx) => {
+        const { pathParams: { appId, resourceType }, } = ctx;
+        const { createAppResourcesWithAssets, getApp, getAppAssets, verifyResourceActionPermission } = options;
+        const action = 'create';
+        const app = await getApp({ context: ctx, query: { where: { id: appId } } });
+        const resourceDefinition = getResourceDefinition(app, resourceType, ctx);
+        await verifyResourceActionPermission({ app, context: ctx, action, resourceType, options, ctx });
+        const appAssets = await getAppAssets({ app, context: ctx });
+        const [processedBody, preparedAssets] = processResourceBody(ctx, resourceDefinition, undefined, undefined, appAssets.map((appAsset) => ({ id: appAsset.id, name: appAsset.name })));
+        if (Array.isArray(processedBody) && !processedBody.length) {
+            ctx.body = [];
+            return;
+        }
+        const resources = Array.isArray(processedBody) ? processedBody : [processedBody];
+        let createdResources;
+        const preparedSeedAssets = structuredClone(preparedAssets);
+        const preparedSeedResources = resources.map((resource) => {
+            var _a;
+            const cleanResource = { ...resource };
+            if (app.demoMode) {
+                for (const referencedProperty of Object.keys((_a = resourceDefinition.references) !== null && _a !== void 0 ? _a : {})) {
+                    delete cleanResource[referencedProperty];
+                }
+            }
+            return {
+                ...cleanResource,
+                $seed: true,
+                $ephemeral: false,
+            };
+        });
+        for (const preparedSeedAsset of preparedSeedAssets) {
+            const index = resources.findIndex(({ $clonable: clonable, $ephemeral: ephemeral, $seed: seed, ...cleanResource }) => {
+                const { $clonable, $ephemeral, $seed, ...cleanAssetResource } = preparedSeedAsset.resource;
+                return isDeepStrictEqual(cleanResource, cleanAssetResource);
+            });
+            const previousAssetId = preparedSeedAsset.id;
+            const newAssetId = randomUUID();
+            const updatedResource = JSON.parse(JSON.stringify(preparedSeedResources[index]).replace(previousAssetId, newAssetId));
+            preparedSeedAsset.id = newAssetId;
+            preparedSeedAsset.resource = updatedResource;
+            preparedSeedResources[index] = updatedResource;
+        }
+        createdResources = await createAppResourcesWithAssets({
+            app,
+            context: ctx,
+            resources: preparedSeedResources,
+            preparedAssets: preparedSeedAssets,
+            resourceType,
+            action,
+            options,
+        });
+        if (app.demoMode) {
+            createdResources = await createAppResourcesWithAssets({
+                app,
+                context: ctx,
+                resources: resources.map((resource) => ({
+                    ...resource,
+                    $seed: false,
+                    $ephemeral: true,
+                    $clonable: false,
+                })),
+                preparedAssets,
+                resourceType,
+                action,
+                options,
+            });
+        }
+        ctx.body = Array.isArray(processedBody) ? createdResources : createdResources[0];
+    };
+}
+export function createDeleteSeedResources(options) {
+    return async (ctx) => {
+        var _a;
+        const { pathParams: { appId }, } = ctx;
+        const { deleteAppResource, getApp, getAppResources } = options;
+        const app = await getApp({ context: ctx, query: { where: { id: appId } } });
+        for (const resourceType of Object.keys((_a = app.definition.resources) !== null && _a !== void 0 ? _a : {})) {
+            const resourcesToDeleteFindOptions = {
+                where: {
+                    type: resourceType,
+                    AppId: appId,
+                    or: [{ seed: true }, { ephemeral: true }],
+                },
+            };
+            const resourcesToDelete = await getAppResources({
+                app,
+                findOptions: resourcesToDeleteFindOptions,
+                type: resourceType,
+                context: ctx,
+            });
+            for (const resourceToDelete of resourcesToDelete) {
+                await deleteAppResource({
+                    app,
+                    context: ctx,
+                    options,
+                    id: resourceToDelete.id,
+                    type: resourceType,
+                });
+            }
+        }
+    };
+}
 //# sourceMappingURL=resources.js.map

package/server/controllers/resources.test.js

@@ -11,7 +11,6 @@ let mockParseQuery;
 let mockGetAppUrl;
 let mockGetAppMessages;
 let mockCreateAppResourcesWithAssets;
-let mockCheckSeededResources;
 let mockGetAppAssets;
 let mockCtx;
 let mockCtxIs;
@@ -429,7 +428,6 @@ describe('createCreateResource', () => {
         mockGetApp = vi.fn();
         mockVerifyResourceActionPermission = vi.fn();
         mockCreateAppResourcesWithAssets = vi.fn();
-        mockCheckSeededResources = vi.fn();
         mockGetAppAssets = vi.fn();
         mockCtxIs = vi.fn();
         mockCtx = {
@@ -453,13 +451,11 @@ describe('createCreateResource', () => {
         mockGetApp.mockResolvedValue(mockApp);
         mockCtxIs.mockReturnValue('multipart/form-data');
         mockCreateAppResourcesWithAssets.mockResolvedValue(mockResources);
-        mockCheckSeededResources.mockResolvedValue(false);
         mockGetAppAssets.mockResolvedValue([]);
         const middleware = createCreateResource({
             getApp: mockGetApp,
             createAppResourcesWithAssets: mockCreateAppResourcesWithAssets,
             verifyResourceActionPermission: mockVerifyResourceActionPermission,
-            checkSeededResources: mockCheckSeededResources,
             getAppAssets: mockGetAppAssets,
         });
         await middleware(mockCtx, vi.fn());
@@ -514,13 +510,11 @@ describe('createCreateResource', () => {
         mockGetApp.mockResolvedValue(mockApp);
         mockCtxIs.mockReturnValue('multipart/form-data');
         mockCreateAppResourcesWithAssets.mockResolvedValue(mockResources);
-        mockCheckSeededResources.mockResolvedValue(false);
         mockGetAppAssets.mockResolvedValue([]);
         const middleware = createCreateResource({
             getApp: mockGetApp,
             createAppResourcesWithAssets: mockCreateAppResourcesWithAssets,
             verifyResourceActionPermission: mockVerifyResourceActionPermission,
-            checkSeededResources: mockCheckSeededResources,
             getAppAssets: mockGetAppAssets,
         });
         await middleware(mockCtx, vi.fn());

package/server/types.d.ts

@@ -125,9 +125,6 @@ export interface GetAppSubEntityParams {
     context: ParameterizedContext<DefaultState, DefaultContextInterface, any>;
     app: App;
 }
-export interface CheckSeededResourcesParams extends GetAppSubEntityParams {
-    resourceType: string;
-}
 export interface GetAppMessagesParams extends GetAppSubEntityParams {
     language?: string;
     merge?: string[] | string;
@@ -274,7 +271,6 @@ export interface DeleteAppResourceParams extends GetAppSubEntityParams {
     id: number | string;
     type: string;
     whereOptions?: WhereOptions;
-    action: ResourceAction;
     options: Options;
 }
 export interface CreateAppAssetParams extends GetAppSubEntityParams {
@@ -376,6 +372,5 @@ export interface Options {
     deleteAppAsset: (params: DeleteAppAssetParams) => Promise<number>;
     email: (params: EmailParams) => Promise<void>;
     sendNotifications: (params: SendNotificationsParams) => Promise<void>;
-    checkSeededResources: (params: CheckSeededResourcesParams) => Promise<boolean>;
 }
 export {};