@appweaver/core 1.0.0

package/factory/create-model.js

@@ -0,0 +1,366 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModel = createModel;
+const node_path_1 = __importDefault(require("node:path"));
+const typebox_1 = require("@sinclair/typebox");
+const common_1 = require("@appweaver/common");
+const context_1 = require("../context");
+const resource_1 = require("../resource");
+function createModel(config, override = false) {
+    const name = (0, common_1.capitalize)(config.name || node_path_1.default.basename(node_path_1.default.dirname(__dirname)));
+    const idSchema = buildIdSchema(config?.id);
+    const auditSchema = buildAuditSchema(config?.audit);
+    const scalarsSchema = buildScalarsSchema(config?.scalars);
+    const virtualSchema = buildScalarsSchema(config?.virtual);
+    const filesSchema = buildFilesSchema(config?.files);
+    const relationsSchema = buildRelationsSchema(config?.relations);
+    const readModel = typebox_1.Type.Composite([
+        idSchema,
+        scalarsSchema,
+        virtualSchema,
+        relationsSchema,
+        filesSchema,
+        auditSchema
+    ], {
+        $id: name
+    });
+    const virtualModel = typebox_1.Type.Composite([virtualSchema], {
+        $id: `${name}Virtual`
+    });
+    const relationsModel = typebox_1.Type.Composite([relationsSchema], {
+        $id: `${name}Relations`
+    });
+    const filesModel = typebox_1.Type.Composite([filesSchema], { $id: `${name}Files` });
+    const baseReadModel = omitOrPickScalars(typebox_1.Type.Composite([idSchema, scalarsSchema, virtualSchema, auditSchema]), config.read);
+    const createModel = omitOrPickScalars(resolveDefaultScalars(typebox_1.Type.Composite([scalarsSchema, virtualSchema]), config), config.create);
+    const updateModel = omitOrPickScalars(resolveDefaultScalars(typebox_1.Type.Partial(typebox_1.Type.Composite([scalarsSchema, virtualSchema])), config), config.update);
+    const { readOneModel, readManyModel } = buildOutputModels(baseReadModel, relationsModel, filesModel, config);
+    const { createOneModel, updateOneModel } = buildInputModels(createModel, updateModel, relationsModel, config);
+    const { fileUploadModel, fileDeleteModel } = buildFileInputModels(config);
+    const resourceModel = {
+        name,
+        config: config,
+        readModel,
+        createModel,
+        updateModel,
+        relationsModel,
+        filesModel,
+        virtualModel,
+        readOneModel,
+        readManyModel,
+        createOneModel,
+        updateOneModel,
+        fileUploadModel,
+        fileDeleteModel
+    };
+    for (const value of Object.values(resourceModel)) {
+        if ((0, common_1.isObject)(value)) {
+            value[common_1.RESOURCE_NAME] = name;
+        }
+    }
+    resourceModel[common_1.RESOURCE_NAME] = name;
+    resourceModel[common_1.RESOURCE_TYPE] = common_1.RESOURCE_MODEL_TYPE;
+    common_1.logger.debug({ modelName: name }, 'Created resource model');
+    (0, context_1.define)(resourceModel, undefined, override ? 'override' : undefined);
+    return resourceModel;
+}
+function buildIdSchema(idField = { type: 'int' }) {
+    let idType;
+    switch (idField.type) {
+        case 'string':
+            idType = resource_1.IdString;
+            break;
+        case 'int':
+        case 'bigInt':
+        default:
+            idType = resource_1.Id;
+    }
+    return idType;
+}
+function buildAuditSchema(audit = {}) {
+    const defaultAudit = {
+        updatedAt: true,
+        createdAt: true,
+        createdById: true
+    };
+    const mergedAudit = { ...defaultAudit, ...audit };
+    const fields = [];
+    for (const [name, included] of Object.entries(mergedAudit)) {
+        if (included) {
+            fields.push(name);
+        }
+    }
+    return typebox_1.Type.Pick(resource_1.AuditData, fields);
+}
+function buildScalarsSchema(fields = {}) {
+    const properties = {};
+    for (const [name, field] of Object.entries(fields)) {
+        properties[name] = buildScalarSchema(field);
+    }
+    return typebox_1.Type.Object(properties);
+}
+function buildScalarSchema(field) {
+    let fieldType;
+    switch (field.type) {
+        case 'string':
+            fieldType = typebox_1.Type.String((0, common_1.pickProperties)(field, [
+                'minLength',
+                'maxLength',
+                'format',
+                'pattern',
+                'hidden',
+                'example'
+            ]));
+            break;
+        case 'int':
+        case 'bigInt':
+            fieldType = typebox_1.Type.Integer((0, common_1.pickProperties)(field, ['minimum', 'maximum', 'hidden', 'example']));
+            break;
+        case 'float':
+            fieldType = typebox_1.Type.Number((0, common_1.pickProperties)(field, ['minimum', 'maximum', 'hidden', 'example']));
+            break;
+        case 'boolean':
+            fieldType = typebox_1.Type.Boolean((0, common_1.pickProperties)(field, ['hidden', 'example']));
+            break;
+        case 'dateTime':
+            fieldType = (0, common_1.StringDate)((0, common_1.pickProperties)(field, ['format', 'hidden', 'example']));
+            break;
+        case 'json':
+            fieldType = (0, common_1.AnyJson)((0, common_1.pickProperties)(field, ['hidden', 'example']));
+            break;
+        case 'enum':
+            fieldType = (0, common_1.StringEnum)(field.values ?? [], (0, common_1.pickProperties)(field, ['hidden', 'example']));
+            break;
+    }
+    if (field.array === true) {
+        fieldType = typebox_1.Type.Array(fieldType);
+    }
+    if (field.required === false) {
+        fieldType = (0, common_1.Nullable)(fieldType);
+    }
+    return fieldType;
+}
+function omitOrPickScalars(type, operationConfig) {
+    let restrictedType = type;
+    if (operationConfig?.pick) {
+        restrictedType = typebox_1.Type.Pick(type, operationConfig.pick);
+    }
+    else if (operationConfig?.omit) {
+        restrictedType = typebox_1.Type.Omit(type, operationConfig.omit);
+    }
+    return typebox_1.Type.Composite([restrictedType]);
+}
+function resolveDefaultScalars(type, config) {
+    for (const name of Object.keys(type.properties)) {
+        const field = type.properties[name];
+        if (config?.scalars?.[name]?.default !== undefined ||
+            config?.virtual?.[name]?.default !== undefined) {
+            type.properties[name] = typebox_1.Type.Optional(field);
+        }
+    }
+    return type;
+}
+function buildFilesSchema(files = {}) {
+    const properties = {};
+    for (const [name, file] of Object.entries(files)) {
+        properties[name] = buildFileSchema(file);
+    }
+    return typebox_1.Type.Object(properties);
+}
+function buildFileSchema(file) {
+    const fileSchema = typebox_1.Type.Ref('FileSingle');
+    return file.array ? typebox_1.Type.Array(fileSchema) : (0, common_1.Nullable)(fileSchema);
+}
+function buildRelationsSchema(relations = {}) {
+    const properties = {};
+    for (const [name, relation] of Object.entries(relations)) {
+        properties[name] = buildRelationSchema(relation);
+    }
+    return typebox_1.Type.Object(properties);
+}
+function buildRelationSchema(relation) {
+    const modelName = (0, common_1.capitalize)(relation.model);
+    const modelRefName = `${modelName}Single`;
+    let relationType = typebox_1.Type.Ref(modelRefName);
+    relationType = relation.array
+        ? typebox_1.Type.Array(relationType, (0, common_1.pickProperties)(relation, ['minItems']))
+        : relationType;
+    return relation.required === false
+        ? typebox_1.Type.Optional(relationType)
+        : relationType;
+}
+function buildOutputModels(readModel, relationsModel, filesModel, config) {
+    const virtualConfig = config.virtual;
+    const relationsConfig = config.relations;
+    const filesConfig = config.files;
+    const adjustedReadModel = removeHiddenFields(readModel);
+    const readOneModel = typebox_1.Type.Composite([
+        resolveOutputVirtualFields(adjustedReadModel, virtualConfig, 'single'),
+        relationOutputProperties(relationsModel, relationsConfig, 'single'),
+        relationOutputProperties(filesModel, filesConfig, 'single')
+    ], { $id: `${config.name}Single` });
+    const readManyModel = typebox_1.Type.Composite([
+        resolveOutputVirtualFields(adjustedReadModel, virtualConfig, 'multiple'),
+        relationOutputProperties(relationsModel, relationsConfig, 'multiple'),
+        relationOutputProperties(filesModel, filesConfig, 'multiple')
+    ], { $id: `${config.name}Multiple` });
+    return { readOneModel, readManyModel };
+}
+function buildInputModels(createModel, updateModel, relationsModel, config) {
+    const virtualConfig = config.virtual;
+    const relationsConfig = config.relations;
+    const adjustedCreateModel = resolveInputVirtualFields(removeHiddenFields(createModel), virtualConfig, 'create');
+    const adjustedUpdateModel = resolveInputVirtualFields(removeHiddenFields(updateModel), virtualConfig, 'update');
+    if (Object.keys(relationsConfig ?? {}).length === 0) {
+        return {
+            createOneModel: adjustedCreateModel,
+            updateOneModel: adjustedUpdateModel
+        };
+    }
+    const relationCreateInputs = relationInputProperties(relationsModel, relationsConfig, 'create');
+    const createOneModel = typebox_1.Type.Composite([adjustedCreateModel, relationCreateInputs], {
+        $id: `${config.name}Create`
+    });
+    const relationUpdateInputs = relationInputProperties(relationsModel, relationsConfig, 'update');
+    const updateOneModel = typebox_1.Type.Composite([adjustedUpdateModel, typebox_1.Type.Partial(relationUpdateInputs)], { $id: `${config.name}Update` });
+    return { createOneModel, updateOneModel };
+}
+function buildFileInputModels(config) {
+    const fileConfig = config.files ?? {};
+    const FileUpload = typebox_1.Type.Unsafe({
+        type: 'string',
+        format: 'binary',
+        [typebox_1.Kind]: 'String'
+    });
+    const FileDelete = typebox_1.Type.String({ example: 'image_123.png' });
+    const fileUploadModel = typebox_1.Type.Object(Object.fromEntries(Object.entries(fileConfig).map(([key, conf]) => [
+        key,
+        typebox_1.Type.Optional(conf.array ? typebox_1.Type.Array(FileUpload) : FileUpload)
+    ])), { $id: `${config.name}FileUpload` });
+    const fileDeleteModel = typebox_1.Type.Object(Object.fromEntries(Object.entries(fileConfig).map(([key, conf]) => [
+        key,
+        typebox_1.Type.Optional(conf.array ? typebox_1.Type.Array(FileDelete) : FileDelete)
+    ])), { $id: `${config.name}FileDelete` });
+    return { fileUploadModel, fileDeleteModel };
+}
+function relationInputProperties(object, relationConfig, inputType) {
+    const relationInputType = (key) => {
+        const { type, ...options } = object.properties[key];
+        const uniqueIdObject = resource_1.Id;
+        const uniqueIdType = resource_1.Id.properties.id;
+        let fullInputType = undefined;
+        const config = relationConfig?.[key];
+        if (config) {
+            if (shouldSkipInputField(config.input?.type, inputType)) {
+                return undefined;
+            }
+            if (config.input?.fullModel) {
+                fullInputType = typebox_1.Type.Ref(`${config.model}Create`);
+            }
+        }
+        const isArray = type === 'array';
+        const isOptional = config?.required === false;
+        const idObjectSchema = isArray
+            ? typebox_1.Type.Array(uniqueIdObject, options)
+            : uniqueIdObject;
+        const idTypeSchema = isArray
+            ? typebox_1.Type.Array(uniqueIdType, options)
+            : uniqueIdType;
+        const inputTypeSchemas = [
+            isOptional ? (0, common_1.Nullable)(idObjectSchema) : idObjectSchema,
+            isOptional ? (0, common_1.Nullable)(idTypeSchema) : idTypeSchema
+        ];
+        if (fullInputType) {
+            const fullInputTypeSchema = isArray
+                ? typebox_1.Type.Array(fullInputType, options)
+                : fullInputType;
+            inputTypeSchemas.push(isOptional ? (0, common_1.Nullable)(fullInputTypeSchema) : fullInputTypeSchema);
+        }
+        const unionSchema = typebox_1.Type.Union(inputTypeSchemas);
+        return isOptional ? typebox_1.Type.Optional(unionSchema) : unionSchema;
+    };
+    return typebox_1.Type.Object({
+        ...Object.keys(object.properties).reduce((acc, key) => {
+            const type = relationInputType(key);
+            if (type) {
+                acc[key] = type;
+            }
+            return acc;
+        }, {})
+    });
+}
+function relationOutputProperties(object, relationConfig, outputType) {
+    const relationOutputType = (key) => {
+        let schema = object.properties[key];
+        const config = relationConfig?.[key];
+        if (config) {
+            if (shouldSkipOutputField(config.output?.type, outputType)) {
+                return undefined;
+            }
+            if (config.required === false && schema.type !== 'array') {
+                schema = (0, common_1.Nullable)(schema);
+            }
+        }
+        return schema;
+    };
+    const relationCountType = (key) => {
+        const config = relationConfig?.[key];
+        if (!config?.output?.count) {
+            return undefined;
+        }
+        return typebox_1.Type.Integer({ minimum: 0 });
+    };
+    return typebox_1.Type.Object({
+        ...Object.keys(object.properties).reduce((acc, key) => {
+            const type = relationOutputType(key);
+            if (type) {
+                acc[key] = type;
+            }
+            const countType = relationCountType(key);
+            if (countType) {
+                acc[(0, common_1.countFieldName)(key)] = countType;
+            }
+            return acc;
+        }, {})
+    });
+}
+function removeHiddenFields(schema) {
+    const properties = {};
+    for (const [name, field] of Object.entries(schema.properties)) {
+        if (!field.hidden) {
+            properties[name] = field;
+        }
+    }
+    return typebox_1.Type.Object(properties);
+}
+function resolveInputVirtualFields(schema, virtualConfig, inputType) {
+    const excludeFields = [];
+    for (const [name, virtual] of Object.entries(virtualConfig ?? {})) {
+        if (shouldSkipInputField(virtual.input?.type, inputType)) {
+            excludeFields.push(name);
+        }
+    }
+    return typebox_1.Type.Omit(schema, excludeFields);
+}
+function resolveOutputVirtualFields(schema, virtualConfig, outputType) {
+    const excludeFields = [];
+    for (const [name, virtual] of Object.entries(virtualConfig ?? {})) {
+        if (shouldSkipOutputField(virtual.output?.type, outputType)) {
+            excludeFields.push(name);
+        }
+    }
+    return typebox_1.Type.Omit(schema, excludeFields);
+}
+function shouldSkipInputField(fieldInputType, methodInputType) {
+    return (fieldInputType === 'none' ||
+        (methodInputType === 'create' && fieldInputType === 'update') ||
+        (methodInputType === 'update' && fieldInputType === 'create'));
+}
+function shouldSkipOutputField(fieldOutputType, methodOutputType) {
+    return (fieldOutputType === 'none' ||
+        (methodOutputType === 'single' && fieldOutputType === 'multiple') ||
+        (methodOutputType === 'multiple' && fieldOutputType === 'single'));
+}

package/factory/create-policy.d.ts

@@ -0,0 +1,2 @@
+import { ResourcePolicyConfig } from '@appweaver/common';
+export declare function createPolicy<T = any>(config: ResourcePolicyConfig<T>, override?: boolean): ResourcePolicyConfig<T>;

package/factory/create-policy.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPolicy = createPolicy;
+const node_path_1 = __importDefault(require("node:path"));
+const common_1 = require("@appweaver/common");
+const context_1 = require("../context");
+function createPolicy(config, override = false) {
+    config[common_1.RESOURCE_NAME] = (0, common_1.capitalize)(config.modelName || node_path_1.default.basename(node_path_1.default.dirname(__dirname)));
+    config[common_1.RESOURCE_TYPE] = common_1.RESOURCE_POLICY_TYPE;
+    common_1.logger.debug({ modelName: config.modelName }, 'Created resource policy');
+    (0, context_1.define)(config, undefined, override ? 'override' : undefined);
+    return config;
+}

package/factory/create-routes.d.ts

@@ -0,0 +1,2 @@
+import { ResourceRoutes, ResourceRoutesConfig } from '@appweaver/common';
+export declare function createRoutes(config: ResourceRoutesConfig, override?: boolean): ResourceRoutes;

package/factory/create-routes.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRoutes = createRoutes;
+const node_path_1 = __importDefault(require("node:path"));
+const common_1 = require("@appweaver/common");
+const context_1 = require("../context");
+const resource_1 = require("../resource");
+function createRoutes(config, override = false) {
+    const name = (0, common_1.capitalize)(config.modelName || node_path_1.default.basename(node_path_1.default.dirname(__dirname)));
+    const basePath = config.path || (0, common_1.camelToSnakeCase)((0, common_1.plural)(name), '-').toLowerCase();
+    const handler = (0, resource_1.resourceRoutes)(name, config);
+    const routeData = { config, basePath, handler };
+    routeData[common_1.RESOURCE_NAME] = name;
+    routeData[common_1.RESOURCE_TYPE] = common_1.RESOURCE_ROUTES_TYPE;
+    common_1.logger.debug({ modelName: config.modelName }, 'Created resource routes');
+    (0, context_1.define)(routeData, undefined, override ? 'override' : undefined);
+    return routeData;
+}

package/factory/create-service.d.ts

@@ -0,0 +1,3 @@
+import { Ctor, ResourceServiceConfig } from '@appweaver/common';
+import { ResourceService } from '../resource';
+export declare function createService<T = any, C = any, U = any>(config: ResourceServiceConfig<T, C, U>, override?: boolean): Ctor<ResourceService<T, T, C, U>>;

package/factory/create-service.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createService = createService;
+const node_path_1 = __importDefault(require("node:path"));
+const common_1 = require("@appweaver/common");
+const context_1 = require("../context");
+const resource_1 = require("../resource");
+function createService(config, override = false) {
+    const name = (0, common_1.capitalize)(config.modelName || node_path_1.default.basename(node_path_1.default.dirname(__dirname)));
+    class Service extends resource_1.ResourceService {
+        [common_1.CONFIG] = config;
+        [common_1.RESOURCE_NAME] = name;
+        [common_1.RESOURCE_TYPE] = common_1.RESOURCE_SERVICE_TYPE;
+        constructor() {
+            super(name);
+        }
+        async find(id) {
+            await config.beforeFind?.(id);
+            const result = await super.find(id);
+            await config.afterFind?.(result);
+            return result;
+        }
+        async query(filter = {}, page = 1, size = 50, sort = '-createdAt,id') {
+            await config.beforeQuery?.(filter, page, size, sort);
+            const result = await super.query(filter, page, size, sort);
+            await config.afterQuery?.(result);
+            return result;
+        }
+        async aggregate(filter = {}, select, dateField = 'createdAt', from, to, step, safeIncrement = true) {
+            await config.beforeAggregate?.(filter, select, dateField, from, to, step, safeIncrement);
+            const result = await super.aggregate(filter, select, dateField, from, to, step, safeIncrement);
+            await config.afterAggregate?.(result);
+            return result;
+        }
+        async create(data) {
+            await config.beforeCreate?.(data);
+            const result = await super.create(data);
+            await config.afterCreate?.(result);
+            return result;
+        }
+        async update(id, data) {
+            await config.beforeUpdate?.(id, data);
+            const result = await super.update(id, data);
+            await config.afterUpdate?.(result);
+            return result;
+        }
+        async delete(id) {
+            await config.beforeDelete?.(id);
+            const result = await super.delete(id);
+            await config.afterDelete?.(result);
+            return result;
+        }
+        textSearchQuery(searchText) {
+            if ((0, common_1.isFunction)(config.textSearch)) {
+                return config.textSearch(searchText);
+            }
+            if ((0, common_1.isObject)(config.textSearch)) {
+                return config.textSearch;
+            }
+            return super.textSearchQuery(searchText);
+        }
+        async readRestrictions(action, data) {
+            const policy = (0, context_1.injectPolicy)(name);
+            if (policy.readRestrictions) {
+                return policy.readRestrictions(action, data) ?? {};
+            }
+            return super.readRestrictions(action, data);
+        }
+        async writeRestrictions(action, data) {
+            const policy = (0, context_1.injectPolicy)(name);
+            if (policy.writeRestrictions) {
+                return policy.writeRestrictions(action, data) ?? {};
+            }
+            return super.writeRestrictions(action, data);
+        }
+        async checkAccess(action, resource) {
+            const policy = (0, context_1.injectPolicy)(name);
+            if (policy?.checkAccess) {
+                return policy.checkAccess(action, resource);
+            }
+            return super.checkAccess(action, resource);
+        }
+    }
+    Object.defineProperty(Service, 'name', {
+        value: `${name}Service`,
+        configurable: true
+    });
+    Service[common_1.CONFIG] = config;
+    Service[common_1.RESOURCE_NAME] = name;
+    Service[common_1.RESOURCE_TYPE] = common_1.RESOURCE_SERVICE_TYPE;
+    common_1.logger.debug({ modelName: config.modelName }, 'Created resource service');
+    (0, context_1.define)(Service, undefined, override ? 'override' : undefined);
+    return Service;
+}

package/factory/index.d.ts

@@ -0,0 +1,4 @@
+export * from './create-model';
+export * from './create-policy';
+export * from './create-routes';
+export * from './create-service';

package/factory/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-model"), exports);
+__exportStar(require("./create-policy"), exports);
+__exportStar(require("./create-routes"), exports);
+__exportStar(require("./create-service"), exports);

package/health/health-routes.d.ts

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

package/health/health-routes.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.health = health;
+const common_1 = require("@appweaver/common");
+const health_schema_1 = require("./health-schema");
+const health_service_1 = require("./health-service");
+const context_1 = require("../context");
+function health(server) {
+    const { authenticate } = server;
+    const healthService = (0, context_1.inject)(health_service_1.HealthService);
+    const healthCheckSchema = (0, health_schema_1.createHealthCheckSchema)(healthService.healthCheckInstances().map((s) => s.name));
+    server.get('/check', {
+        schema: healthCheckSchema,
+        onRequest: common_1.config.HEALTH_CHECK_AUTH ? authenticate() : undefined,
+        config: {
+            cacheTTL: common_1.config.HEALTH_CHECK_CACHE_TTL,
+            rateLimit: {
+                max: 12
+            }
+        }
+    }, async (_, reply) => {
+        const healthCheck = await healthService.checkHealth();
+        const allUp = Object.values(healthCheck).every((check) => check.status === common_1.HealthCheckStatus.Up);
+        return reply.status(allUp ? 200 : 503).send({
+            status: allUp ? common_1.HealthCheckStatus.Up : common_1.HealthCheckStatus.Down,
+            timestamp: new Date(),
+            checks: healthCheck
+        });
+    });
+    server.get('/ready', {
+        schema: health_schema_1.healthReadySchema
+    }, async (_, reply) => {
+        const ready = await healthService.checkReadiness();
+        return reply.send({ ready });
+    });
+}

package/health/health-schema.d.ts

@@ -0,0 +1,45 @@
+import { HealthCheckStatus, RouteSchema } from '@appweaver/common';
+export declare const HealthCheckResult: import("@sinclair/typebox").TObject<{
+    status: import("@sinclair/typebox").TUnsafe<HealthCheckStatus>;
+    message: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export declare const HealthCheckCommonData: import("@sinclair/typebox").TObject<{
+    status: import("@sinclair/typebox").TUnsafe<HealthCheckStatus>;
+    timestamp: import("@sinclair/typebox").TUnsafe<Date>;
+}>;
+export declare const ReadyResponse: import("@sinclair/typebox").TObject<{
+    ready: import("@sinclair/typebox").TBoolean;
+}>;
+export declare const healthReadySchema: {
+    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<{
+            ready: import("@sinclair/typebox").TBoolean;
+        }>;
+    };
+};
+export declare function createHealthCheckSchema(serviceNames: string[]): RouteSchema;