@appweaver/core 1.0.0

package/security/store/database-security-store.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseSecurityStore = void 0;
+const common_1 = require("@appweaver/common");
+const context_1 = require("../../context");
+const errors_1 = require("../../errors");
+class DatabaseSecurityStore extends common_1.SecurityStore {
+    /** @internal */
+    _db = (0, context_1.inject)(common_1.Database);
+    async generateOneTimeToken(purpose, data, ttl) {
+        const token = (0, common_1.generateToken)('bytes', 64);
+        await this._db.client().oneTimeToken.create({
+            data: {
+                tokenHash: (0, common_1.makeHash)(token),
+                purpose,
+                expiresAt: new Date(Date.now() + ttl),
+                data: data
+            }
+        });
+        return token;
+    }
+    async useOneTimeToken(token, purpose, validateContent) {
+        const oneTimeToken = await this._db.client().oneTimeToken.findFirst({
+            where: {
+                purpose,
+                tokenHash: (0, common_1.makeHash)(token)
+            }
+        });
+        if (oneTimeToken === null ||
+            oneTimeToken.expiresAt.getTime() < Date.now()) {
+            if (oneTimeToken) {
+                await this.removeOneTimeToken(oneTimeToken.id);
+            }
+            throw new errors_1.HttpError('Invalid or expired token provided', 401);
+        }
+        const data = oneTimeToken.data;
+        if (validateContent) {
+            const result = validateContent(data);
+            if (!result.valid) {
+                throw new errors_1.HttpError(result.message, 401);
+            }
+        }
+        await this.removeOneTimeToken(oneTimeToken.id);
+        return data;
+    }
+    /** @internal */
+    async removeOneTimeToken(id) {
+        await this._db.client().oneTimeToken.delete({ where: { id } });
+    }
+}
+exports.DatabaseSecurityStore = DatabaseSecurityStore;

package/security/store/redis-security-store.d.ts

@@ -0,0 +1,5 @@
+import { SecurityStore, ValidationResult } from '@appweaver/common';
+export declare class RedisSecurityStore extends SecurityStore {
+    generateOneTimeToken<T = any>(purpose: string, data: T, ttl: number): Promise<string>;
+    useOneTimeToken<T = any>(token: string, purpose: string, validateContent?: (value: T) => ValidationResult): Promise<T>;
+}

package/security/store/redis-security-store.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisSecurityStore = void 0;
+const common_1 = require("@appweaver/common");
+const context_1 = require("../../context");
+const errors_1 = require("../../errors");
+const SECURITY_OTT_KEY = 'security:ott';
+class RedisSecurityStore extends common_1.SecurityStore {
+    /** @internal */
+    _redis = (0, context_1.inject)(common_1.Redis);
+    async generateOneTimeToken(purpose, data, ttl) {
+        const token = (0, common_1.generateToken)('bytes', 64);
+        await this._redis.putValue(`${SECURITY_OTT_KEY}:${purpose}:${(0, common_1.makeHash)(token)}`, data, ttl);
+        return token;
+    }
+    async useOneTimeToken(token, purpose, validateContent) {
+        const tokenKey = `${SECURITY_OTT_KEY}:${purpose}:${(0, common_1.makeHash)(token)}`;
+        const value = await this._redis.getValue(tokenKey);
+        if (value === null) {
+            throw new errors_1.HttpError('Invalid or expired token provided', 401);
+        }
+        if (validateContent) {
+            const result = validateContent(value);
+            if (!result.valid) {
+                throw new errors_1.HttpError(result.message, 401);
+            }
+        }
+        await this._redis.removeValue(tokenKey);
+        return value;
+    }
+}
+exports.RedisSecurityStore = RedisSecurityStore;

package/seeder/create-seeder.d.ts

@@ -0,0 +1,21 @@
+import { Seeder } from './seeder';
+export type CreateSeederParams = {
+    /** A relative path where the application source code is located.
+     * This is usually the directory from which the createApp() function is called.
+     * (default: ./dist/src) */
+    scanPath?: string;
+    /** A relative path where the seeder functions are located.
+     * (default: ./dist/database/seeders) */
+    seedersPath?: string;
+    /** A flag indication if the seeder should continue execution even if an error occurs.
+     * (default: false) */
+    continueOnError?: boolean;
+    /** A boolean flag indicating whether the seeder should automatically
+     * start seeding after being created. (default: true) **/
+    autoSeed?: boolean;
+    /** A boolean flag indicating whether to automatically fix all warnings
+     * related to the seeders like wrong checksum or deleted seeder files.
+     * (default: false) **/
+    fixWarnings?: boolean;
+};
+export declare function createSeeder(params?: CreateSeederParams): Promise<Seeder>;

package/seeder/create-seeder.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSeeder = createSeeder;
+const common_1 = require("@appweaver/common");
+const load_providers_1 = require("../app/load-providers");
+const seeder_1 = require("./seeder");
+async function createSeeder(params = {}) {
+    const scanPath = (0, common_1.resolveSourcePath)(common_1.config.APP_BUILD_PATH, common_1.config.APP_SOURCE_PATH, params.scanPath, './dist/src');
+    const seedersPath = (0, common_1.resolveSourcePath)(common_1.config.APP_BUILD_PATH, common_1.config.DATABASE_SEEDERS_DIR_PATH, params.seedersPath, './dist/database/seeders');
+    // Load all defined providers from this project
+    (0, load_providers_1.loadProviders)(scanPath);
+    const seeder = new seeder_1.Seeder(seedersPath, params.continueOnError, params.fixWarnings);
+    if (params.autoSeed !== false) {
+        await seeder.seed();
+    }
+    return seeder;
+}

package/seeder/index.d.ts

@@ -0,0 +1,2 @@
+export * from './create-seeder';
+export * from './seeder';

package/seeder/index.js

@@ -0,0 +1,18 @@
+"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("./create-seeder"), exports);
+__exportStar(require("./seeder"), exports);

package/seeder/resources/seeder/model.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@appweaver/common").ResourceModel;
+export default _default;

package/seeder/resources/seeder/model.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const factory_1 = require("../../../factory");
+exports.default = (0, factory_1.createModel)({
+    name: 'Seeder',
+    tableName: '_seeders',
+    generateTypes: false,
+    id: {
+        type: 'string',
+        generator: 'uuid()'
+    },
+    audit: {
+        updatedAt: false,
+        createdAt: false,
+        createdById: false
+    },
+    scalars: {
+        checksum: {
+            type: 'string',
+            maxLength: 255
+        },
+        seederName: {
+            type: 'string',
+            unique: true,
+            maxLength: 511
+        },
+        startedAt: {
+            type: 'dateTime'
+        },
+        finishedAt: {
+            type: 'dateTime'
+        },
+        logs: {
+            type: 'string',
+            required: false
+        }
+    }
+});

package/seeder/seeder.d.ts

@@ -0,0 +1,20 @@
+import { LifecycleManager } from '../app/lifecycle-manager';
+/**
+ * Represents a seeder class that manages the application seeders processes.
+ */
+export declare class Seeder extends LifecycleManager {
+    private readonly _dirPath;
+    private readonly _continueOnError;
+    private readonly _fixWarnings;
+    constructor(_dirPath: string, _continueOnError?: boolean, _fixWarnings?: boolean);
+    /**
+     * Executes the seeders by discovering, validating, and running seeder files.
+     * Logs the seeding process, including warnings for checksum mismatches
+     * and files that do not exist but are present in database table.
+     *
+     * @return Resolves when all seeders have been processed. Logs relevant
+     * information during execution.
+     */
+    seed(): Promise<void>;
+    close(): Promise<void>;
+}

package/seeder/seeder.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Seeder = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const common_1 = require("@appweaver/common");
+const lifecycle_manager_1 = require("../app/lifecycle-manager");
+const context_1 = require("../context");
+/**
+ * Represents a seeder class that manages the application seeders processes.
+ */
+class Seeder extends lifecycle_manager_1.LifecycleManager {
+    _dirPath;
+    _continueOnError;
+    _fixWarnings;
+    /** @internal */
+    _db = (0, context_1.inject)(common_1.Database);
+    constructor(_dirPath, _continueOnError = false, _fixWarnings = false) {
+        super();
+        this._dirPath = _dirPath;
+        this._continueOnError = _continueOnError;
+        this._fixWarnings = _fixWarnings;
+    }
+    /**
+     * Executes the seeders by discovering, validating, and running seeder files.
+     * Logs the seeding process, including warnings for checksum mismatches
+     * and files that do not exist but are present in database table.
+     *
+     * @return Resolves when all seeders have been processed. Logs relevant
+     * information during execution.
+     */
+    async seed() {
+        await this.init();
+        let seederFiles = [];
+        try {
+            seederFiles = await this.loadSeederFiles();
+        }
+        catch (error) {
+            console.error(`Seeders directory ${this._dirPath} is not accessible`);
+            return;
+        }
+        let calledSeedersCount = 0;
+        const relativePath = this._dirPath
+            .replace(process.cwd(), '.')
+            .replace(/\\/g, '/');
+        console.log(`${seederFiles.length} seeder${seederFiles.length === 1 ? '' : 's'} found in ${relativePath}`);
+        console.log('');
+        // For each seeder file, skip if it has already been seeded, otherwise
+        // execute all of it's exported functions and write results to a database
+        for (const seederFile of seederFiles) {
+            const seederName = this.seederName(seederFile);
+            const seeder = await this.getSeeder(seederFile);
+            if (seeder) {
+                const checksum = await this.seederHash(seederFile);
+                if (checksum !== seeder.checksum) {
+                    console.warn(`Warning: seeder ${seederName} has different checksum: ${checksum}, expected checksum: ${seeder.checksum}`);
+                    if (this._fixWarnings) {
+                        await this._db.client().seeder.update({
+                            where: { id: seeder.id },
+                            data: { checksum }
+                        });
+                        console.log('Fix: seeder checksum updated');
+                    }
+                    console.log('');
+                }
+                continue;
+            }
+            console.log(`Seeding ${seederName}...`);
+            await this.executeSeeder(seederFile);
+            console.log(`${seederName} seeded`);
+            console.log('');
+            calledSeedersCount++;
+        }
+        const seedersWithoutFiles = await this.findSeedersWithoutFiles(seederFiles);
+        for (const seeder of seedersWithoutFiles) {
+            console.warn(`Warning: seeder ${seeder.seederName} does not exist but is present in database table`);
+            if (this._fixWarnings) {
+                await this._db.client().seeder.delete({ where: { id: seeder.id } });
+                console.log('Fix: removed seeder from database');
+            }
+            console.log('');
+        }
+        if (calledSeedersCount === 0) {
+            console.log(`No pending seeders to execute`);
+        }
+        else {
+            console.log(`Executed ${calledSeedersCount} seeder${calledSeedersCount === 1 ? '' : 's'}`);
+        }
+    }
+    async close() {
+        await this.destroy();
+    }
+    /** @internal */
+    async loadSeederFiles() {
+        const entries = await promises_1.default.readdir(this._dirPath, { withFileTypes: true });
+        return entries
+            .filter((e) => e.isFile() && /\.(js|ts)$/.test(e.name) && !e.name.endsWith('.d.ts'))
+            .map((e) => e.name)
+            .sort((a, b) => a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' }))
+            .map((name) => node_path_1.default.join(this._dirPath, name));
+    }
+    /** @internal */
+    async executeSeeder(seederFile) {
+        const start = new Date();
+        const { value, error } = await (0, common_1.importModule)(seederFile);
+        if (error) {
+            if (this._continueOnError) {
+                console.error(error);
+                return;
+            }
+            throw error;
+        }
+        const logs = [];
+        // Execute all exported functions from a seeder file and log errors or
+        // function responses
+        for (const seederFn of Object.values(value)) {
+            if ((0, common_1.isFunction)(seederFn)) {
+                try {
+                    const result = await seederFn();
+                    if (result) {
+                        logs.push(JSON.stringify(result));
+                    }
+                }
+                catch (e) {
+                    if (!this._continueOnError) {
+                        throw e;
+                    }
+                    console.error(e);
+                    logs.push(`Error: ${e.message}`);
+                }
+            }
+        }
+        const seederHash = await this.seederHash(seederFile);
+        // Insert seeder result into the database
+        await this._db.client().seeder.create({
+            data: {
+                checksum: seederHash,
+                seederName: this.seederName(seederFile),
+                startedAt: start,
+                finishedAt: new Date(),
+                logs: logs.length > 0 ? logs.join('\n') : null
+            }
+        });
+    }
+    /** @internal */
+    async findSeedersWithoutFiles(seederFiles) {
+        const seederNames = seederFiles.map((file) => this.seederName(file));
+        return this._db.client().seeder.findMany({
+            where: {
+                seederName: { notIn: seederNames }
+            }
+        });
+    }
+    /** @internal */
+    async getSeeder(seederFile) {
+        const seederName = this.seederName(seederFile);
+        return this._db.client().seeder.findFirst({ where: { seederName } });
+    }
+    /** @internal */
+    async seederHash(seederFile) {
+        const seederContent = await promises_1.default.readFile(seederFile, 'utf8');
+        return (0, common_1.makeHash)(seederContent);
+    }
+    /** @internal */
+    seederName(seederFile) {
+        if (seederFile.endsWith('.ts')) {
+            return node_path_1.default.basename(seederFile, '.ts');
+        }
+        return node_path_1.default.basename(seederFile, '.js');
+    }
+}
+exports.Seeder = Seeder;

package/server/create-server.d.ts

@@ -0,0 +1,20 @@
+import { Server } from '../types';
+/**
+ * Creates and configures a new server instance.
+ *
+ * This function initializes a Fastify server with various plugins and configurations,
+ * including CORS, security rules (e.g., Helmet), multipart file uploads, rate limiting,
+ * static file serving, authentication, and Swagger documentation (if enabled).
+ * It also sets a global error handler for all routes.
+ *
+ * Additionally, this function:
+ * - Loads and registers all user-defined plugins
+ * - Registers schema models for route validation with $ref support
+ * - Sets up a global error handler for all routes
+ * - Registers built-in routes (health check, info, files)
+ * - Loads and registers resource API routes generated from the resource context
+ * - Loads and registers user-defined custom routes
+ *
+ * @return {Server} A configured Fastify server instance with TypeBox type provider.
+ */
+export declare function createServer(): Server;

package/server/create-server.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServer = createServer;
+const node_path_1 = __importDefault(require("node:path"));
+const fastify_1 = __importDefault(require("fastify"));
+const cors_1 = __importDefault(require("@fastify/cors"));
+const helmet_1 = __importDefault(require("@fastify/helmet"));
+const static_1 = __importDefault(require("@fastify/static"));
+const rate_limit_1 = __importDefault(require("@fastify/rate-limit"));
+const multipart_1 = __importDefault(require("@fastify/multipart"));
+const request_context_1 = require("@fastify/request-context");
+const common_1 = require("@appweaver/common");
+const context_1 = require("../context");
+const errors_1 = require("../errors");
+const storage_1 = require("../storage");
+const health_1 = require("../health");
+const auth_1 = __importDefault(require("../security/auth"));
+const caching_1 = __importDefault(require("../cache/caching"));
+const info_route_1 = require("./info-route");
+const schemas_1 = __importDefault(require("./schemas"));
+const swagger_1 = __importDefault(require("./swagger"));
+/**
+ * Creates and configures a new server instance.
+ *
+ * This function initializes a Fastify server with various plugins and configurations,
+ * including CORS, security rules (e.g., Helmet), multipart file uploads, rate limiting,
+ * static file serving, authentication, and Swagger documentation (if enabled).
+ * It also sets a global error handler for all routes.
+ *
+ * Additionally, this function:
+ * - Loads and registers all user-defined plugins
+ * - Registers schema models for route validation with $ref support
+ * - Sets up a global error handler for all routes
+ * - Registers built-in routes (health check, info, files)
+ * - Loads and registers resource API routes generated from the resource context
+ * - Loads and registers user-defined custom routes
+ *
+ * @return {Server} A configured Fastify server instance with TypeBox type provider.
+ */
+function createServer() {
+    // Create a Fastify server instance
+    const server = (0, fastify_1.default)({
+        ajv: {
+            customOptions: {
+                removeAdditional: 'all'
+            },
+            plugins: [(ajv) => ajv.addKeyword('example')]
+        },
+        routerOptions: {
+            maxParamLength: 512,
+            caseSensitive: false
+        },
+        trustProxy: common_1.config.SERVER_TRUST_PROXY,
+        bodyLimit: (0, common_1.textToBytes)(common_1.config.SERVER_BODY_MAX_SIZE),
+        disableRequestLogging: !common_1.config.SERVER_REQUEST_LOGGING_ENABLED,
+        logger: common_1.loggerConfig
+    }).withTypeProvider();
+    // Register CORS rules
+    server.register(cors_1.default, {
+        origin: common_1.config.CORS_ORIGIN,
+        methods: common_1.config.CORS_METHODS,
+        allowedHeaders: common_1.config.CORS_ALLOWED_HEADERS,
+        exposedHeaders: common_1.config.CORS_EXPOSED_HEADERS,
+        maxAge: common_1.config.CORS_MAX_AGE,
+        credentials: common_1.config.CORS_CREDENTIALS
+    });
+    // Register security rules
+    server.register(helmet_1.default, {
+        contentSecurityPolicy: {
+            directives: {
+                ...helmet_1.default.contentSecurityPolicy.getDefaultDirectives(),
+                'connect-src': ['*']
+            }
+        }
+    });
+    // Register static public file serving
+    if (common_1.config.SERVER_STATIC_ENABLED) {
+        server.register(static_1.default, {
+            root: node_path_1.default.isAbsolute(common_1.config.SERVER_STATIC_DIR_PATH)
+                ? common_1.config.SERVER_STATIC_DIR_PATH
+                : node_path_1.default.join(process.cwd(), common_1.config.SERVER_STATIC_DIR_PATH),
+            prefix: common_1.config.SERVER_STATIC_ROUTE_PREFIX,
+            maxAge: common_1.config.SERVER_STATIC_MAX_AGE,
+            prefixAvoidTrailingSlash: true,
+            constraints: common_1.config.SERVER_STATIC_ALLOWED_HOST
+                ? { host: common_1.config.SERVER_STATIC_ALLOWED_HOST }
+                : {}
+        });
+    }
+    // Register multipart file upload plugin
+    server.register(multipart_1.default, { throwFileSizeLimit: false });
+    // Register global request rate limiter
+    if (common_1.config.RATE_LIMIT_ENABLED) {
+        server.register(rate_limit_1.default, {
+            max: common_1.config.RATE_LIMIT_MAX,
+            timeWindow: common_1.config.RATE_LIMIT_WINDOW,
+            allowList: common_1.config.RATE_LIMIT_ALLOW_LIST,
+            nameSpace: 'rate-limit:',
+            redis: common_1.config.RATE_LIMIT_STORE === common_1.MemoryType.Redis
+                ? (0, context_1.inject)(common_1.Redis).createClient({
+                    connectTimeout: 500,
+                    maxRetriesPerRequest: 1,
+                    lazyConnect: true
+                })
+                : null
+        });
+    }
+    // Register request context plugin with default values
+    server.register(request_context_1.fastifyRequestContext, {
+        defaultStoreValues: {
+            authUser: null,
+            authType: null,
+            authSource: null,
+            apiKey: null,
+            cached: undefined
+        }
+    });
+    // Register all defined plugins
+    const plugins = (0, context_1.injectAll)(common_1.PLUGIN);
+    for (const plugin of plugins) {
+        server.register(plugin);
+    }
+    // Set global error handler for all routes
+    server.setErrorHandler(errors_1.errorHandler);
+    // Register swagger documentation and UI. Must be registered after
+    // loadResources and before any route registration
+    server.register(swagger_1.default);
+    // Register schema models to enable $ref usage in route validation
+    server.register(schemas_1.default);
+    // Register authentication plugin
+    server.register(auth_1.default);
+    // Register caching plugin
+    if (common_1.config.CACHE_ENABLED) {
+        server.register(caching_1.default);
+    }
+    // Register a health route
+    if (common_1.config.HEALTH_CHECK_ENABLED) {
+        server.register(health_1.health, { prefix: common_1.config.HEALTH_CHECK_ROUTE_PREFIX });
+    }
+    // Register files route
+    server.register(storage_1.files, { prefix: common_1.config.STORAGE_FILES_ROUTE_PREFIX });
+    // Register info route
+    server.register(info_route_1.info, { prefix: common_1.config.SERVER_API_PREFIX });
+    // Register resource routes
+    for (const route of context_1.context.resource.routes.values()) {
+        const prefix = [common_1.config.SERVER_API_PREFIX, route.basePath]
+            .join('/')
+            .replaceAll('//', '/');
+        server.register(route.handler, { prefix });
+    }
+    // Register other defined routes
+    const routes = (0, context_1.injectAll)(common_1.ROUTE);
+    for (const route of routes) {
+        server.register(route, { prefix: common_1.config.SERVER_API_PREFIX + '/' });
+    }
+    return server;
+}

package/server/index.d.ts

@@ -0,0 +1,4 @@
+export * from './create-server';
+export * from './register-model';
+export * from './register-plugin';
+export * from './register-route';

package/server/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("./create-server"), exports);
+__exportStar(require("./register-model"), exports);
+__exportStar(require("./register-plugin"), exports);
+__exportStar(require("./register-route"), exports);

package/server/info-route.d.ts

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

package/server/info-route.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.info = info;
+const common_1 = require("@appweaver/common");
+const info_schema_1 = require("./info-schema");
+function info(server) {
+    server.get('/', {
+        schema: info_schema_1.infoSchema,
+        config: {
+            rateLimit: {
+                max: 60
+            }
+        }
+    }, () => ({
+        name: common_1.config.APP_NAME,
+        version: common_1.config.APP_VERSION
+    }));
+}

package/server/info-schema.d.ts

@@ -0,0 +1,37 @@
+export declare const InfoResponse: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+    version: import("@sinclair/typebox").TString;
+}>;
+export declare const infoSchema: {
+    tags: string[];
+    summary: string;
+    description: string;
+    response: {
+        '4xx': {
+            description: string;
+            content: {
+                'application/json': {
+                    schema: import("@sinclair/typebox").TObject<{
+                        errorCode: import("@sinclair/typebox").TInteger;
+                        message: import("@sinclair/typebox").TString;
+                    }>;
+                };
+            };
+        };
+        '5xx': {
+            description: string;
+            content: {
+                'application/json': {
+                    schema: import("@sinclair/typebox").TObject<{
+                        errorCode: import("@sinclair/typebox").TInteger;
+                        message: import("@sinclair/typebox").TString;
+                    }>;
+                };
+            };
+        };
+        200: import("@sinclair/typebox").TObject<{
+            name: import("@sinclair/typebox").TString;
+            version: import("@sinclair/typebox").TString;
+        }>;
+    };
+};