@appweaver/core 1.0.0

package/types/fastify-extensions.d.ts

@@ -0,0 +1,24 @@
+import { AuthSource, AuthType, AuthUser, RouteConfig } from '@appweaver/common';
+import { ApiKey } from './generated';
+import '@fastify/request-context';
+import '@fastify/auth';
+declare module 'fastify' {
+    interface FastifyContextConfig extends RouteConfig {
+    }
+    interface FastifyInstance {
+        recaptcha: (request: FastifyRequest, reply: FastifyReply) => Promise<void>;
+        authenticateJWT: (request: FastifyRequest, reply: FastifyReply) => Promise<void>;
+        authenticateApiKey: (request: FastifyRequest, reply: FastifyReply) => Promise<void>;
+        authenticate: (authTypes?: AuthType[]) => any;
+        currentUser: () => AuthUser;
+    }
+}
+declare module '@fastify/request-context' {
+    interface RequestContextData {
+        authUser: AuthUser | null;
+        authType: AuthType | null;
+        authSource: AuthSource | null;
+        apiKey: ApiKey | null;
+        cached?: boolean;
+    }
+}

package/types/fastify-extensions.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("@fastify/request-context");
+require("@fastify/auth");

package/types/generated.d.ts

@@ -0,0 +1,193 @@
+export type ApiKey = {
+    id: number;
+    key: string;
+    keyHash: string;
+    name?: string | null;
+    description?: string | null;
+    enabled: boolean;
+    expiresAt?: Date | null;
+    updatedAt: Date;
+    createdAt: Date;
+    createdById?: number | null;
+};
+export type ApiKeySingle = {
+    id: number;
+    key: string;
+    name?: string | null;
+    description?: string | null;
+    enabled: boolean;
+    expiresAt?: Date | null;
+    updatedAt: Date;
+    createdAt: Date;
+    createdById?: number | null;
+};
+export type ApiKeyMultiple = {
+    id: number;
+    key: string;
+    name?: string | null;
+    description?: string | null;
+    enabled: boolean;
+    expiresAt?: Date | null;
+    updatedAt: Date;
+    createdAt: Date;
+    createdById?: number | null;
+};
+export type ApiKeyCreate = {
+    name?: string | null;
+    description?: string | null;
+    enabled?: boolean;
+    expiresAt?: Date | null;
+};
+export type ApiKeyUpdate = {
+    name?: string | null;
+    description?: string | null;
+    enabled?: boolean;
+};
+export type OneTimeToken = {
+    id: number;
+    tokenHash: string;
+    purpose: string;
+    expiresAt: Date;
+    data: any;
+    updatedAt: Date;
+    createdAt: Date;
+};
+export type OneTimeTokenSingle = {
+    id: number;
+    tokenHash: string;
+    purpose: string;
+    expiresAt: Date;
+    data: any;
+    updatedAt: Date;
+    createdAt: Date;
+};
+export type OneTimeTokenMultiple = {
+    id: number;
+    tokenHash: string;
+    purpose: string;
+    expiresAt: Date;
+    data: any;
+    updatedAt: Date;
+    createdAt: Date;
+};
+export type OneTimeTokenCreate = {
+    tokenHash: string;
+    purpose: string;
+    expiresAt: Date;
+    data: any;
+};
+export type OneTimeTokenUpdate = {
+    tokenHash?: string;
+    purpose?: string;
+    expiresAt?: Date;
+    data?: any;
+};
+export type Permission = {
+    id: number;
+    name: string;
+    updatedAt: Date;
+    createdAt: Date;
+    createdById?: number | null;
+};
+export type PermissionSingle = {
+    id: number;
+    name: string;
+};
+export type PermissionMultiple = {
+    id: number;
+    name: string;
+};
+export type PermissionCreate = {
+    name: string;
+};
+export type PermissionUpdate = {
+    name?: string;
+};
+export type Role = {
+    id: number;
+    name: string;
+    permissions: Array<PermissionSingle>;
+    updatedAt: Date;
+    createdAt: Date;
+    createdById?: number | null;
+};
+export type RoleSingle = {
+    id: number;
+    name: string;
+    permissions: Array<PermissionSingle>;
+};
+export type RoleMultiple = {
+    id: number;
+    name: string;
+    permissions: Array<PermissionSingle>;
+};
+export type RoleCreate = {
+    name: string;
+    permissions: Array<{
+        id: number;
+    }> | Array<number>;
+};
+export type RoleUpdate = {
+    name?: string;
+    permissions?: Array<{
+        id: number;
+    }> | Array<number>;
+};
+export type File = {
+    id: number;
+    name: string;
+    originalName: string;
+    mimeType: string;
+    sizeBytes: number;
+    title?: string | null;
+    description?: string | null;
+    resourceField?: string | null;
+    resourceName?: string | null;
+    resourceId?: number | null;
+    url: string;
+    updatedAt: Date;
+    createdAt: Date;
+    createdById?: number | null;
+};
+export type FileSingle = {
+    id: number;
+    name: string;
+    originalName: string;
+    mimeType: string;
+    sizeBytes: number;
+    title?: string | null;
+    description?: string | null;
+    url: string;
+    updatedAt: Date;
+    createdAt: Date;
+    createdById?: number | null;
+};
+export type FileMultiple = {
+    id: number;
+    name: string;
+    originalName: string;
+    mimeType: string;
+    sizeBytes: number;
+    title?: string | null;
+    description?: string | null;
+    url: string;
+    updatedAt: Date;
+    createdAt: Date;
+    createdById?: number | null;
+};
+export type FileCreate = {
+    name: string;
+    originalName: string;
+    mimeType: string;
+    sizeBytes: number;
+    title?: string | null;
+    description?: string | null;
+};
+export type FileUpdate = {
+    name?: string;
+    originalName?: string;
+    mimeType?: string;
+    sizeBytes?: number;
+    title?: string | null;
+    description?: string | null;
+};

package/types/generated.js

@@ -0,0 +1,3 @@
+"use strict";
+// Generated by Appweaver. Please do not edit this file manually.
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './application-context';
+export * from './auth';
+export * from './generated';
+export * from './server';

package/types/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./application-context"), exports);
+__exportStar(require("./auth"), exports);
+__exportStar(require("./generated"), exports);
+__exportStar(require("./server"), exports);

package/types/server.d.ts

@@ -0,0 +1,4 @@
+import { FastifyBaseLogger, FastifyInstance, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerDefault } from 'fastify';
+import { TypeBoxTypeProvider } from '@fastify/type-provider-typebox';
+export type Server = FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, FastifyBaseLogger, TypeBoxTypeProvider>;
+export type Router = Pick<Server, 'route' | 'get' | 'post' | 'patch' | 'put' | 'delete' | 'options' | 'head'>;

package/types/server.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/utils/export-util.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Converts an array of data into a CSV-formatted string.
+ *
+ * @param {Object[]} data - The array of data to be converted into CSV format.
+ * @param {boolean} [header=false] - Whether to include a header row in the generated CSV.
+ * @return {string} The CSV-formatted string representation of the input data.
+ */
+export declare function toCsv(data: any[], header?: boolean): string;

package/utils/export-util.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCsv = toCsv;
+const sync_1 = require("csv-stringify/sync");
+const common_1 = require("@appweaver/common");
+/**
+ * Converts an array of data into a CSV-formatted string.
+ *
+ * @param {Object[]} data - The array of data to be converted into CSV format.
+ * @param {boolean} [header=false] - Whether to include a header row in the generated CSV.
+ * @return {string} The CSV-formatted string representation of the input data.
+ */
+function toCsv(data, header = false) {
+    return (0, sync_1.stringify)(Object.values(data), {
+        delimiter: common_1.config.EXPORT_CSV_DELIMITER,
+        cast: {
+            date: (value) => value.toISOString(),
+            object: (value) => (0, common_1.isArray)(value) &&
+                ((0, common_1.isString)(value) || (0, common_1.isNumber)(value) || (0, common_1.isBoolean)(value))
+                ? value.join(common_1.config.EXPORT_CSV_JOIN_DELIMITER)
+                : JSON.stringify(value)
+        },
+        header
+    });
+}

package/utils/file-util.d.ts

@@ -0,0 +1,64 @@
+import { FilesConfig } from '@appweaver/common';
+import { File } from '../types';
+/**
+ * Parses a range string and converts it into an object with start and end values.
+ *
+ * @param {string} [range] - The range string to parse, typically in the format "bytes=start-end".
+ * @return {{start: number, end?: number}} An object containing the start value and an optional end value.
+ */
+export declare function parseRange(range?: string): {
+    start: number;
+    end?: number;
+};
+/**
+ * Calculates the maximum file size allowed based on the provided file configuration.
+ *
+ * @param {FilesConfig} fileConfig - An object containing file configuration data, including maximum size for each file
+ * type.
+ * @return {number} The maximum size in bytes allowed for any file based on the given configuration.
+ */
+export declare function maxFileSize(fileConfig: FilesConfig): number;
+/**
+ * Converts a given size represented as a string or number into its equivalent size in bytes.
+ *
+ * @param {string | number} [size] - The size to be converted, either as a string or a number.
+ * @return {number} The size in bytes. Returns 0 if the input is invalid or not provided.
+ */
+export declare function sizeInBytes(size?: string | number): number;
+/**
+ * Validates if the provided MIME type matches a given pattern or regular expression.
+ *
+ * @param {string} mimeType - The MIME type to validate.
+ * @param {string|RegExp} [mimeTypeExp] - An optional pattern or regular expression to match the MIME type against.
+ *                                       If not provided, the method will always return true.
+ * @return {boolean} True if the MIME type matches the specified pattern or regular expression, false otherwise.
+ */
+export declare function isValidMimeType(mimeType: string, mimeTypeExp?: string | RegExp): boolean;
+/**
+ * Generates a file name based on a given name, an optional pattern, and a set of variables.
+ *
+ * @param {string} name The original file name including its extension.
+ * @param {string} [pattern] An optional pattern to customize the generated file name. If not provided, a default
+ * pattern will be used.
+ * @param {Record<string, any>} [variables={}] Additional variables to replace in the pattern. These can include custom
+ * placeholders to dynamically generate the file name.
+ * @return {string} The generated, sanitized file name based on the provided or default pattern.
+ */
+export declare function generateFileName(name: string, pattern?: string, variables?: Record<string, any>): string;
+/**
+ * Sanitizes a given filename by removing invalid characters that are not allowed in file systems.
+ *
+ * @param fileName The original filename to sanitize.
+ * @return A sanitized filename with invalid characters removed.
+ */
+export declare function sanitizeFilename(fileName: string): string;
+/**
+ * Aggregates the provided files into a structured object based on the given configuration.
+ *
+ * @param {File[]} files - An array of file objects to be processed and aggregated.
+ * @param {FilesConfig} filesConfig - An object that defines the configuration for each file field, including whether
+ * the field supports multiple files.
+ * @return {Record<string, File | File[] | null>} A record where keys correspond to the configured fields, and values
+ * are either a single file, an array of files, or null if no files match the field.
+ */
+export declare function aggregateFiles(files: File[], filesConfig: FilesConfig): Record<string, File | File[] | null>;

package/utils/file-util.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRange = parseRange;
+exports.maxFileSize = maxFileSize;
+exports.sizeInBytes = sizeInBytes;
+exports.isValidMimeType = isValidMimeType;
+exports.generateFileName = generateFileName;
+exports.sanitizeFilename = sanitizeFilename;
+exports.aggregateFiles = aggregateFiles;
+const common_1 = require("@appweaver/common");
+/**
+ * Parses a range string and converts it into an object with start and end values.
+ *
+ * @param {string} [range] - The range string to parse, typically in the format "bytes=start-end".
+ * @return {{start: number, end?: number}} An object containing the start value and an optional end value.
+ */
+function parseRange(range) {
+    if (!range) {
+        return { start: 0 };
+    }
+    const parts = range.replace(/bytes=/, '').split('-');
+    const start = parseInt(parts[0], 10);
+    const end = parts[1] ? parseInt(parts[1], 10) : undefined;
+    return { start, end };
+}
+/**
+ * Calculates the maximum file size allowed based on the provided file configuration.
+ *
+ * @param {FilesConfig} fileConfig - An object containing file configuration data, including maximum size for each file
+ * type.
+ * @return {number} The maximum size in bytes allowed for any file based on the given configuration.
+ */
+function maxFileSize(fileConfig) {
+    const sizes = Object.values(fileConfig)
+        .map((conf) => sizeInBytes(conf.maxSize))
+        .filter((v) => v > 0);
+    if (!sizes.length) {
+        return (0, common_1.textToBytes)(common_1.config.SERVER_BODY_MAX_SIZE);
+    }
+    return Math.max(...sizes);
+}
+/**
+ * Converts a given size represented as a string or number into its equivalent size in bytes.
+ *
+ * @param {string | number} [size] - The size to be converted, either as a string or a number.
+ * @return {number} The size in bytes. Returns 0 if the input is invalid or not provided.
+ */
+function sizeInBytes(size) {
+    return (0, common_1.isString)(size) ? (0, common_1.textToBytes)(size) : 0;
+}
+/**
+ * Validates if the provided MIME type matches a given pattern or regular expression.
+ *
+ * @param {string} mimeType - The MIME type to validate.
+ * @param {string|RegExp} [mimeTypeExp] - An optional pattern or regular expression to match the MIME type against.
+ *                                       If not provided, the method will always return true.
+ * @return {boolean} True if the MIME type matches the specified pattern or regular expression, false otherwise.
+ */
+function isValidMimeType(mimeType, mimeTypeExp) {
+    if (!mimeTypeExp) {
+        return true;
+    }
+    else if (mimeTypeExp instanceof RegExp) {
+        return mimeTypeExp.test(mimeType);
+    }
+    else {
+        const regexPattern = mimeTypeExp
+            .replace(/[.+?^$]/g, '\\$&')
+            .replace(/\*/g, '.*');
+        const regex = new RegExp(`^${regexPattern}$`);
+        return regex.test(mimeType);
+    }
+}
+/**
+ * Generates a file name based on a given name, an optional pattern, and a set of variables.
+ *
+ * @param {string} name The original file name including its extension.
+ * @param {string} [pattern] An optional pattern to customize the generated file name. If not provided, a default
+ * pattern will be used.
+ * @param {Record<string, any>} [variables={}] Additional variables to replace in the pattern. These can include custom
+ * placeholders to dynamically generate the file name.
+ * @return {string} The generated, sanitized file name based on the provided or default pattern.
+ */
+function generateFileName(name, pattern, variables = {}) {
+    const nameParts = name.split('.');
+    let extension = '';
+    let nameWithoutExtension = name;
+    if (nameParts.length > 1) {
+        extension = nameParts.pop();
+        nameWithoutExtension = nameParts.join('.');
+    }
+    const defaultPattern = common_1.config.STORAGE_NAME_PATTERN ?? '{name}-{hash}.{extension}';
+    let fileName = (0, common_1.replacePatternVariables)(pattern ?? defaultPattern, {
+        name: nameWithoutExtension,
+        extension,
+        ...variables
+    });
+    fileName = sanitizeFilename(fileName);
+    fileName = fileName.endsWith('.')
+        ? fileName.substring(0, fileName.length - 1)
+        : fileName;
+    return fileName || name;
+}
+/**
+ * Sanitizes a given filename by removing invalid characters that are not allowed in file systems.
+ *
+ * @param fileName The original filename to sanitize.
+ * @return A sanitized filename with invalid characters removed.
+ */
+function sanitizeFilename(fileName) {
+    return fileName.replace(/[\\:*?"<>|]/g, '');
+}
+/**
+ * Aggregates the provided files into a structured object based on the given configuration.
+ *
+ * @param {File[]} files - An array of file objects to be processed and aggregated.
+ * @param {FilesConfig} filesConfig - An object that defines the configuration for each file field, including whether
+ * the field supports multiple files.
+ * @return {Record<string, File | File[] | null>} A record where keys correspond to the configured fields, and values
+ * are either a single file, an array of files, or null if no files match the field.
+ */
+function aggregateFiles(files, filesConfig) {
+    const aggregated = Object.entries(filesConfig)
+        .map(([field, value]) => ({ [field]: value.array ? [] : null }))
+        .reduce((acc, obj) => Object.assign(acc, obj), {});
+    for (const file of files) {
+        const resourceField = file.resourceField;
+        if (resourceField) {
+            if (filesConfig[resourceField].array) {
+                if (!aggregated[resourceField]) {
+                    aggregated[resourceField] = [];
+                }
+                aggregated[resourceField].push(file);
+            }
+            else {
+                aggregated[resourceField] = file;
+            }
+        }
+    }
+    return aggregated;
+}

package/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './export-util';
+export * from './file-util';
+export * from './schema-util';

package/utils/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./export-util"), exports);
+__exportStar(require("./file-util"), exports);
+__exportStar(require("./schema-util"), exports);

package/utils/schema-util.d.ts

@@ -0,0 +1,20 @@
+import { TObject } from '@sinclair/typebox';
+/**
+ * Creates a schema model by defining it with the given name and schema object. This function returns a TypeBox
+ * reference to the created schema model.
+ *
+ * @param {TObject} schema - The schema object defining the structure of the model.
+ * @param {Object} config - Configuration options for schema model creation.
+ * @param {string} [config.name] - The name of the schema model to be referenced by. If not provided, then
+ * `schema.$id` or `schema.title` will be used by default. If both are `undefined`, then a generic name will be used.
+ * @param {boolean} [config.addToServer] - Whether to add the schema to the server instance. Defaults to `true`.
+ * @param {boolean} [config.skipExisting] - Whether to skip creating a schema model if it is alredy created with the
+ * same name. Defaults to `true`.
+ * @return {TObject} A reference to the created schema model, but returned type will be the model it references, so
+ * this function can be used while building schema properties and provide type support in routes.
+ */
+export declare function createSchemaModel<T extends TObject>(schema: T, config?: {
+    name?: string;
+    addToServer?: boolean;
+    skipExisting?: boolean;
+}): T;

package/utils/schema-util.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSchemaModel = createSchemaModel;
+const typebox_1 = require("@sinclair/typebox");
+const common_1 = require("@appweaver/common");
+const context_1 = require("../context");
+/**
+ * Creates a schema model by defining it with the given name and schema object. This function returns a TypeBox
+ * reference to the created schema model.
+ *
+ * @param {TObject} schema - The schema object defining the structure of the model.
+ * @param {Object} config - Configuration options for schema model creation.
+ * @param {string} [config.name] - The name of the schema model to be referenced by. If not provided, then
+ * `schema.$id` or `schema.title` will be used by default. If both are `undefined`, then a generic name will be used.
+ * @param {boolean} [config.addToServer] - Whether to add the schema to the server instance. Defaults to `true`.
+ * @param {boolean} [config.skipExisting] - Whether to skip creating a schema model if it is alredy created with the
+ * same name. Defaults to `true`.
+ * @return {TObject} A reference to the created schema model, but returned type will be the model it references, so
+ * this function can be used while building schema properties and provide type support in routes.
+ */
+function createSchemaModel(schema, config = {}) {
+    const existingModels = context_1.context.definitions.filter((d) => d.name === common_1.MODEL);
+    const name = config.name ??
+        schema.$id ??
+        schema.title ??
+        `Object${existingModels.length}`;
+    const reference = typebox_1.Type.Ref(name);
+    if (existingModels.find((m) => m.name === name) &&
+        config.skipExisting !== false) {
+        return reference;
+    }
+    (0, context_1.define)({ name, schema }, common_1.MODEL, 'append');
+    if (context_1.context.server && config.addToServer !== false) {
+        context_1.context.server.addSchema({ ...schema, $id: name });
+    }
+    return reference;
+}