@appweaver/core 1.0.0

package/server/info-schema.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.infoSchema = exports.InfoResponse = void 0;
+const typebox_1 = require("@sinclair/typebox");
+const errors_1 = require("../errors");
+const utils_1 = require("../utils");
+exports.InfoResponse = typebox_1.Type.Object({
+    name: typebox_1.Type.String(),
+    version: typebox_1.Type.String()
+}, { $id: 'InfoResponse' });
+exports.infoSchema = {
+    tags: ['Info'],
+    summary: 'Application info',
+    description: 'Application info',
+    response: {
+        200: (0, utils_1.createSchemaModel)(exports.InfoResponse),
+        ...errors_1.AllErrorResponses
+    }
+};

package/server/register-model.d.ts

@@ -0,0 +1,2 @@
+import { TObject } from '@sinclair/typebox';
+export declare function registerModel(schema: TObject, name?: string): void;

package/server/register-model.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerModel = registerModel;
+const common_1 = require("@appweaver/common");
+const utils_1 = require("../utils");
+function registerModel(schema, name) {
+    const refType = (0, utils_1.createSchemaModel)(schema, {
+        name,
+        addToServer: false
+    });
+    common_1.logger.debug({ modelName: refType.$ref }, 'Registered model');
+}

package/server/register-plugin.d.ts

@@ -0,0 +1,2 @@
+import { Server } from '../types';
+export declare function registerPlugin(name: string, plugin: (server: Server) => void, dependencies?: string[]): void;

package/server/register-plugin.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPlugin = registerPlugin;
+const fastify_plugin_1 = __importDefault(require("fastify-plugin"));
+const common_1 = require("@appweaver/common");
+const context_1 = require("../context");
+function registerPlugin(name, plugin, dependencies = []) {
+    (0, context_1.define)((0, fastify_plugin_1.default)(plugin, { name, dependencies }), common_1.PLUGIN, 'append');
+    common_1.logger.debug({ plugin: name, dependencies }, 'Registered plugin');
+}

package/server/register-route.d.ts

@@ -0,0 +1,3 @@
+import { RouteCacheConfig, RouteConfig } from '@appweaver/common';
+import { Router } from '../types';
+export declare function registerRoute(handler: (router: Router) => void, config?: RouteConfig & RouteCacheConfig): void;

package/server/register-route.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRoute = registerRoute;
+const fastify_1 = __importDefault(require("fastify"));
+const typebox_1 = require("@sinclair/typebox");
+const common_1 = require("@appweaver/common");
+const context_1 = require("../context");
+const security_1 = require("../security");
+const errors_1 = require("../errors");
+function registerRoute(handler, config) {
+    const routes = [];
+    const tempServer = (0, fastify_1.default)({
+        logger: false,
+        ajv: {
+            plugins: [(ajv) => ajv.addKeyword('example')]
+        }
+    });
+    tempServer.addHook('onRoute', (routeOptions) => {
+        routes.push(routeOptions);
+    });
+    tempServer.register(handler);
+    const routeBuilder = async (server) => {
+        const { authenticate, recaptcha } = server;
+        // Add all currently configured schemas to the temporary server
+        for (const [id, schema] of Object.entries(server.getSchemas())) {
+            if (!tempServer.getSchema(id)) {
+                tempServer.addSchema({ ...schema, $id: id });
+            }
+        }
+        // Route array will be filled via the 'onRoute' hook after this step
+        await tempServer.ready();
+        for (const route of routes) {
+            const recaptchaHeader = (0, security_1.recaptchaHeaderSchema)({
+                recaptcha: config?.recaptcha,
+                recaptchaAction: config?.recaptchaAction
+            });
+            // Merge received route schema with default values based on configuration
+            const mergedRoute = {
+                ...route,
+                schema: {
+                    ...route.schema,
+                    security: config?.public
+                        ? []
+                        : (0, security_1.authSchema)(config?.auth),
+                    headers: route.schema?.headers
+                        ? typebox_1.Type.Composite([
+                            recaptchaHeader,
+                            typebox_1.Type.Composite([route.schema.headers])
+                        ])
+                        : recaptchaHeader,
+                    response: {
+                        ...(route.schema?.response ?? {}),
+                        ...errors_1.AllErrorResponses
+                    }
+                },
+                onRequest: [
+                    config?.public ? undefined : authenticate(config?.auth),
+                    config?.recaptcha || config?.recaptchaAction ? recaptcha : undefined,
+                    ...((0, common_1.isArray)(route.onRequest) ? route.onRequest : [route.onRequest])
+                ].filter((h) => h !== undefined),
+                config: {
+                    ...config,
+                    ...route.config
+                }
+            };
+            common_1.logger.debug({ method: mergedRoute.method, url: mergedRoute.url }, 'Registered route');
+            server.route(mergedRoute);
+        }
+    };
+    (0, context_1.define)(routeBuilder, common_1.ROUTE, 'append');
+}

package/server/schemas.d.ts

@@ -0,0 +1,3 @@
+import { Server } from '../types';
+declare const _default: (server: Server) => void;
+export default _default;

package/server/schemas.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fastify_plugin_1 = __importDefault(require("fastify-plugin"));
+const common_1 = require("@appweaver/common");
+const context_1 = require("../context");
+exports.default = (0, fastify_plugin_1.default)((server) => {
+    const usedSchemas = new Set();
+    // Add all resource models schemas
+    for (const model of context_1.context.resource.models.values()) {
+        for (const [suffix, property] of Object.entries(common_1.resourceModelProps)) {
+            const modelName = `${model.name}${suffix}`;
+            const modelSchema = model[property].$defs[modelName];
+            usedSchemas.add(modelSchema);
+        }
+    }
+    // Add additional schemas for registered models
+    const models = (0, context_1.injectAll)(common_1.MODEL);
+    for (const model of models) {
+        usedSchemas.add({ ...model.schema, $id: model.name });
+    }
+    // Add used schemas to the server instance
+    for (const schema of usedSchemas.values()) {
+        if (schema.$id && !server.getSchema(schema.$id)) {
+            server.addSchema({ ...schema });
+        }
+    }
+});

package/server/swagger.d.ts

@@ -0,0 +1,3 @@
+import { Server } from '../types';
+declare const _default: (server: Server) => void;
+export default _default;

package/server/swagger.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fastify_plugin_1 = __importDefault(require("fastify-plugin"));
+const swagger_1 = __importDefault(require("@fastify/swagger"));
+const swagger_ui_1 = __importDefault(require("@fastify/swagger-ui"));
+const common_1 = require("@appweaver/common");
+const context_1 = require("../context");
+exports.default = (0, fastify_plugin_1.default)((server) => {
+    server.register(swagger_1.default, {
+        hideUntagged: common_1.config.SWAGGER_HIDE_UNTAGGED,
+        transformObject: (document) => addConfig(pruneUnusedSchemas(document)),
+        openapi: {
+            info: {
+                title: common_1.config.APP_NAME,
+                description: common_1.config.APP_DESCRIPTION,
+                version: common_1.config.APP_VERSION
+            },
+            externalDocs: {
+                url: 'https://swagger.io',
+                description: 'Find more info here'
+            },
+            servers: [
+                {
+                    url: common_1.config.APP_HOSTNAME
+                }
+            ],
+            tags: [],
+            components: {
+                securitySchemes: {
+                    bearer: {
+                        scheme: 'bearer',
+                        bearerFormat: 'token',
+                        type: 'http'
+                    },
+                    ...(common_1.config.SECURITY_API_KEY_ENABLED
+                        ? {
+                            apiKeyAuth: {
+                                type: 'apiKey',
+                                in: 'header',
+                                name: common_1.config.SECURITY_API_KEY_HEADER_NAME
+                            }
+                        }
+                        : {}),
+                    ...(common_1.config.SECURITY_BASIC_ENABLED
+                        ? {
+                            basicAuth: {
+                                type: 'http',
+                                scheme: 'basic'
+                            }
+                        }
+                        : {})
+                }
+            }
+        }
+    });
+    if (common_1.config.SWAGGER_ENABLED) {
+        server.register(swagger_ui_1.default, {
+            routePrefix: common_1.config.SWAGGER_PATH,
+            indexPrefix: new URL(common_1.config.APP_HOSTNAME).pathname,
+            staticCSP: false
+        });
+    }
+});
+function pruneUnusedSchemas(document) {
+    const schemas = document.openapiObject.components?.schemas ?? {};
+    const used = new Set();
+    const visit = (node) => {
+        if (!node || typeof node !== 'object')
+            return;
+        if (typeof node.$ref === 'string') {
+            const match = node.$ref.match(/^#\/components\/schemas\/(.+)$/);
+            if (match) {
+                const schemaName = match[1];
+                if (!used.has(schemaName)) {
+                    used.add(schemaName);
+                    visit(schemas[schemaName]);
+                }
+            }
+        }
+        if (Array.isArray(node)) {
+            for (const item of node)
+                visit(item);
+            return;
+        }
+        for (const value of Object.values(node)) {
+            visit(value);
+        }
+    };
+    visit(document.openapiObject.paths);
+    if (document.openapiObject.components?.schemas) {
+        document.openapiObject.components.schemas = Object.fromEntries(Object.entries(document.openapiObject.components.schemas)
+            .sort(([nameA, objA], [nameB, objB]) => String(objA.title ?? nameA).localeCompare(String(objB.title ?? nameB)))
+            .filter(([name]) => used.has(name)));
+    }
+    return document.openapiObject;
+}
+function addConfig(document) {
+    const normalizePath = (path) => {
+        const withLeadingSlash = path.startsWith('/') ? path : `/${path}`;
+        return withLeadingSlash.endsWith('/') && withLeadingSlash.length > 1
+            ? withLeadingSlash.slice(0, -1)
+            : withLeadingSlash;
+    };
+    document[`x-${common_1.CONFIG_NAME}-config`] = {
+        resourcePaths: [...context_1.context.resource.routes.values()].map((r) => ({
+            name: r.config.modelName,
+            basePath: normalizePath(r.basePath)
+        })),
+        routePrefixes: {
+            api: normalizePath(common_1.config.SERVER_API_PREFIX),
+            static: normalizePath(common_1.config.SERVER_STATIC_ROUTE_PREFIX),
+            health: normalizePath(common_1.config.HEALTH_CHECK_ROUTE_PREFIX),
+            auth: normalizePath(common_1.config.SECURITY_ROUTE_PREFIX),
+            account: normalizePath(common_1.config.SECURITY_ACCOUNT_ROUTE_PREFIX),
+            files: normalizePath(common_1.config.STORAGE_FILES_ROUTE_PREFIX)
+        }
+    };
+    return document;
+}

package/storage/file-route.d.ts

@@ -0,0 +1,2 @@
+import { Server } from '../types';
+export declare function files(server: Server): void;

package/storage/file-route.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.files = files;
+const common_1 = require("@appweaver/common");
+const file_service_1 = require("./file-service");
+const file_schema_1 = require("./file-schema");
+const context_1 = require("../context");
+function files(server) {
+    const { authenticate } = server;
+    const fileService = (0, context_1.inject)(file_service_1.FileService);
+    const addHeaders = (reply, data, hasRange) => {
+        reply.header('Accept-Ranges', 'bytes');
+        if (hasRange) {
+            reply.header('Content-Range', `bytes ${data.start}-${data.end}/${data.content.size}`);
+        }
+        reply.header('Content-Length', hasRange ? data.end - data.start + 1 : data.content.size);
+        reply.header('Content-Type', data.mimeType ?? 'application/octet-stream');
+        reply.header('Content-Disposition', 'inline; filename="' + data.fileName + '"');
+        reply.header('Pragma', 'public');
+        reply.header('Cache-Control', `public, max-age=${Math.floor(common_1.config.STORAGE_CACHE_TTL / 1000)}`);
+        reply.header('Expires', new Date(Date.now() + common_1.config.STORAGE_CACHE_TTL).toUTCString());
+        return hasRange ? 206 : 200;
+    };
+    server.get('/public/*', {
+        schema: (0, file_schema_1.createFileAccessSchema)(true)
+    }, async (request, reply) => {
+        const data = await fileService.stream(request.params['*'], request.headers.range);
+        const code = addHeaders(reply, data, !!request.headers.range);
+        return reply.status(code).send(data.content.stream);
+    });
+    server.get('/protected/*', {
+        schema: (0, file_schema_1.createFileAccessSchema)(false),
+        onRequest: authenticate()
+    }, async (request, reply) => {
+        const data = await fileService.stream(request.params['*'], request.headers.range);
+        const code = addHeaders(reply, data, !!request.headers.range);
+        return reply.status(code).send(data.content.stream);
+    });
+}

package/storage/file-schema.d.ts

@@ -0,0 +1,9 @@
+import { RouteSchema } from '@appweaver/common';
+export declare const FileName: import("@sinclair/typebox").TObject<{
+    '*': import("@sinclair/typebox").TString;
+}>;
+export declare const FileRangeHeader: import("@sinclair/typebox").TObject<{
+    Range: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export declare const FileResponse: import("@sinclair/typebox").TString;
+export declare function createFileAccessSchema(isPublic: boolean): RouteSchema;

package/storage/file-schema.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileResponse = exports.FileRangeHeader = exports.FileName = void 0;
+exports.createFileAccessSchema = createFileAccessSchema;
+const typebox_1 = require("@sinclair/typebox");
+const errors_1 = require("../errors");
+exports.FileName = typebox_1.Type.Object({
+    '*': typebox_1.Type.String()
+});
+exports.FileRangeHeader = typebox_1.Type.Object({
+    Range: typebox_1.Type.Optional(typebox_1.Type.String({ example: 'bytes=0-1023' }))
+});
+exports.FileResponse = typebox_1.Type.String({ format: 'binary' });
+function createFileAccessSchema(isPublic) {
+    return {
+        tags: ['Files'],
+        security: isPublic ? [] : [{ bearer: [] }],
+        summary: `Fetch ${isPublic ? 'public' : 'protected'} files`,
+        description: `Fetch ${isPublic ? 'public' : 'protected'} files`,
+        response: {
+            200: {
+                description: 'Binary file content',
+                content: {
+                    'application/octet-stream': {
+                        schema: exports.FileResponse
+                    }
+                }
+            },
+            206: {
+                description: 'Binary partial file content',
+                content: {
+                    'application/octet-stream': {
+                        schema: exports.FileResponse
+                    }
+                }
+            },
+            ...errors_1.AllErrorResponses
+        },
+        params: exports.FileName,
+        headers: exports.FileRangeHeader
+    };
+}

package/storage/file-service.d.ts

@@ -0,0 +1,81 @@
+import { Multipart, MultipartFile } from '@fastify/multipart';
+import { ContentStream, Resource, ResourceClient } from '@appweaver/common';
+import { File } from '../types';
+export type FileStream = {
+    content: ContentStream;
+    fileName: string;
+    mimeType: string;
+    start: number;
+    end: number;
+};
+export declare class FileService {
+    /**
+     * Searches for a file by its name from a database.
+     *
+     * @param {string} fileName - The name of the file to search for.
+     * @return {Promise<File>} A promise that resolves to the file object if found.
+     * @throws {HttpError} Throws an error if a database error occurs or if the file is not found.
+     */
+    findByName(fileName: string): Promise<File>;
+    /**
+     * Streams a file from storage, handling authorization and range-based requests.
+     *
+     * @param {string} fileName - The name of the file to stream.
+     * @param {string} [range] - An optional range header specifying the byte range to stream.
+     * @return {Promise<FileStream>} A promise that resolves to a file stream object containing the content, metadata, and
+     * range details.
+     * @throws {HttpError} Throws a 404 error if the file does not exist.
+     * @throws {HttpError} Throws a 403 error if user access to the file is forbidden.
+     * @throws {HttpError} Throws a 500 error if an error occurs while reading the file from storage.
+     */
+    stream(fileName: string, range?: string): Promise<FileStream>;
+    /**
+     * Saves a file to storage, validates its properties, and associates it with a specific resource and client.
+     *
+     * @param {MultipartFile} data The multipart file object containing the file data, field name, filename, and metadata.
+     * @param {Resource} resource The resource object with which the file is being associated.
+     * @param {ResourceClient} client The database client responsible for handling the resource.
+     * @return {Promise<File>} A promise that resolves to the saved file object or rejects with an error if the operation
+     * fails.
+     * @throws {HttpError} Throws an error if file validation, storage, or resource association fails.
+     */
+    saveFile(data: MultipartFile, resource: Resource, client: ResourceClient): Promise<File>;
+    /**
+     * Saves files received as an asynchronous iterable of multipart data.
+     *
+     * @param {AsyncIterableIterator<Multipart>} parts - The asynchronous iterable providing multipart data where each
+     * part is expected to represent a file or other data.
+     * @param {Resource} resource - The resource associated with the files being saved, providing additional contextual
+     * information.
+     * @param {ResourceClient} client - The database client responsible for handling resource-related operations, such as
+     * database interaction.
+     * @return {Promise<File[]>} A promise that resolves to an array of successfully saved files. Rejects with an error
+     * if one or more files fail to save.
+     */
+    saveFiles(parts: AsyncIterableIterator<Multipart>, resource: Resource, client: ResourceClient): Promise<File[]>;
+    /**
+     * Deletes a file from the storage and database if it meets the specified conditions.
+     *
+     * @param {string} fileName - The name of the file to be deleted.
+     * @param {string} fieldName - The field associated with the resource to which the file belongs.
+     * @param {Resource} resource - The resource that the file is associated with.
+     * @param {ResourceClient} client - The client instance representing the resource's type.
+     * @return {Promise<File>} A promise that resolves with the deleted file information upon successful deletion.
+     * @throws {HttpError} If the file is not associated with the provided resource or client,
+     *                     if the current user does not have permission to delete the file,
+     *                     if there is an error removing the file from storage,
+     *                     or if there is an error deleting the file from the database.
+     */
+    deleteFile(fileName: string, fieldName: string, resource: Resource, client: ResourceClient): Promise<File>;
+    /**
+     * Deletes a list of files associated with a given resource using the provided resource client.
+     *
+     * @param {Record<string, string | string[]>} fileNames - An object where the keys correspond to file fields and the
+     * values are either a string (single file name) or an array of file names to be deleted.
+     * @param {Resource} resource - The resource instance associated with the files to be deleted.
+     * @param {ResourceClient} client - The resource a client used to handle deletion operations.
+     * @return {Promise<File[]>} A promise that resolves to an array of files that were successfully deleted. Rejects with
+     * an error if no files could be deleted.
+     */
+    deleteFiles(fileNames: Record<string, string | string[]>, resource: Resource, client: ResourceClient): Promise<File[]>;
+}