@appweaver/core 1.0.0

package/resource/resource-loader.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadResources = loadResources;
+const typebox_1 = require("@sinclair/typebox");
+const common_1 = require("@appweaver/common");
+/**
+ * Loads application resources including models, services, policies, and routes.
+ *
+ * @param {string} [baseDir] - Optional base directory path from which to load the resources.
+ *                              If not provided, defaults to the application's root directory.
+ * @param {LoadResourcePaths} [paths={}] Path patterns for loading resources: models, services, policies, and routes.
+ * @return {Promise<ResourceContext>} A promise that resolves to an object containing
+ * the loaded resources:
+ *
+ *         - `models`: The application models.
+ *         - `services`: The application services.
+ *         - `policies`: The access policies.
+ *         - `routes`: The application routes.
+ */
+async function loadResources(baseDir, paths = {}) {
+    const models = await loadModels(baseDir, paths.modelPattern);
+    const services = await loadServices(baseDir, paths.servicePattern);
+    const policies = await loadPolicies(baseDir, paths.policyPattern);
+    const routes = await loadRoutes(baseDir, paths.routePattern);
+    return {
+        models: new Map(Object.entries(models)),
+        services: new Map(Object.entries(services)),
+        policies: new Map(Object.entries(policies)),
+        routes: new Map(Object.entries(routes))
+    };
+}
+async function loadModels(baseDir, modelPattern) {
+    const cwd = baseDir ?? process.cwd();
+    const pathPattern = modelPattern || common_1.config.RESOURCE_MODEL_PATTERN;
+    const models = {};
+    const modelPaths = await findAllFiles(pathPattern, cwd);
+    for (const path of modelPaths) {
+        const modelSchema = await importPath(path);
+        if (!modelSchema) {
+            continue;
+        }
+        if ((0, common_1.isResourceModel)(modelSchema)) {
+            models[modelSchema.name] = modelSchema;
+        }
+        else {
+            for (const maybeSchema of Object.values(modelSchema)) {
+                if ((0, common_1.isResourceModel)(maybeSchema)) {
+                    models[maybeSchema.name] = maybeSchema;
+                }
+            }
+        }
+    }
+    // Map model variants to schemas using their corresponding suffixes
+    const resourceModels = {};
+    for (const model of Object.values(models)) {
+        for (const [suffix, property] of Object.entries(common_1.resourceModelProps)) {
+            resourceModels[`${model.name}${suffix}`] = model[property];
+        }
+    }
+    // Resolve all model references through the TypeBox module system
+    const module = typebox_1.Type.Module(resourceModels);
+    // Apply resolved models back to the resource schema definitions
+    for (const model of Object.values(models)) {
+        for (const [suffix, property] of Object.entries(common_1.resourceModelProps)) {
+            const schemaKey = `${model.name}${suffix}`;
+            const importedModel = module.Import(schemaKey);
+            model[property] = importedModel;
+        }
+    }
+    return models;
+}
+async function loadServices(baseDir, servicePattern) {
+    const cwd = baseDir ?? process.cwd();
+    const pathPattern = servicePattern || common_1.config.RESOURCE_SERVICE_PATTERN;
+    const services = {};
+    const servicePaths = await findAllFiles(pathPattern, cwd);
+    for (const path of servicePaths) {
+        const resourceService = await importPath(path);
+        if (!resourceService) {
+            continue;
+        }
+        if ((0, common_1.isResourceService)(resourceService)) {
+            services[resourceService.modelName] = resourceService;
+        }
+        else {
+            for (const maybeService of Object.values(resourceService)) {
+                if ((0, common_1.isResourceService)(maybeService)) {
+                    services[maybeService.modelName] = maybeService;
+                }
+            }
+        }
+    }
+    return services;
+}
+async function loadPolicies(baseDir, policyPattern) {
+    const cwd = baseDir ?? process.cwd();
+    const pathPattern = policyPattern || common_1.config.RESOURCE_POLICY_PATTERN;
+    const policies = {};
+    const policyPaths = await findAllFiles(pathPattern, cwd);
+    for (const path of policyPaths) {
+        const resourcePolicy = await importPath(path);
+        if (!resourcePolicy) {
+            continue;
+        }
+        if ((0, common_1.isResourcePolicy)(resourcePolicy)) {
+            policies[resourcePolicy.modelName] = resourcePolicy;
+        }
+        else {
+            for (const maybePolicy of Object.values(resourcePolicy)) {
+                if ((0, common_1.isResourcePolicy)(maybePolicy)) {
+                    policies[maybePolicy.modelName] = maybePolicy;
+                }
+            }
+        }
+    }
+    return policies;
+}
+async function loadRoutes(baseDir, routePattern) {
+    const cwd = baseDir ?? process.cwd();
+    const pathPattern = routePattern || common_1.config.RESOURCE_ROUTES_PATTERN;
+    const routes = {};
+    const routePaths = await findAllFiles(pathPattern, cwd);
+    for (const path of routePaths) {
+        const resourceRoute = await importPath(path);
+        if (!resourceRoute) {
+            continue;
+        }
+        if ((0, common_1.isResourceRoutes)(resourceRoute)) {
+            routes[resourceRoute.config.modelName] = resourceRoute;
+        }
+        else {
+            for (const maybeRoute of Object.values(resourceRoute)) {
+                if ((0, common_1.isResourceRoutes)(maybeRoute)) {
+                    routes[maybeRoute.config.modelName] = maybeRoute;
+                }
+            }
+        }
+    }
+    return routes;
+}
+async function findAllFiles(pattern, cwd) {
+    const files = [];
+    // Find all project files matching provided glob pattern
+    const projectFiles = await (0, common_1.findFilesByPattern)(pattern, cwd);
+    files.push(...projectFiles);
+    // Add exported core module resources
+    files.push('@appweaver/core/resources');
+    // Add additional modules from config
+    for (const module of common_1.config.APP_AUTOLOAD_MODULES) {
+        files.push(module);
+    }
+    return files;
+}
+async function importPath(filePath) {
+    const { value, error } = await (0, common_1.importModule)(filePath);
+    if (error) {
+        common_1.logger.error(error, 'Resource path import error');
+        return null;
+    }
+    return value;
+}

package/resource/resource-routes.d.ts

@@ -0,0 +1,3 @@
+import { ResourceRoutesConfig } from '@appweaver/common';
+import { Server } from '../types';
+export declare function resourceRoutes(name: string, routesConfig?: Omit<ResourceRoutesConfig, 'modelName' | 'path'>): (server: Server) => void;

package/resource/resource-routes.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resourceRoutes = resourceRoutes;
+const resource_schema_1 = require("./resource-schema");
+const context_1 = require("../context");
+const storage_1 = require("../storage");
+const export_1 = require("../export");
+const utils_1 = require("../utils");
+function resourceRoutes(name, routesConfig = {}) {
+    const routeConfig = (configName) => {
+        return {
+            ...(routesConfig[configName] ?? {}),
+            resourceRouteName: configName,
+            cacheModelName: ['find', 'query', 'aggregate'].includes(configName)
+                ? name
+                : undefined
+        };
+    };
+    const routeNames = [
+        'find',
+        'query',
+        'aggregate',
+        'create',
+        'update',
+        'delete',
+        'export',
+        'fileUpload',
+        'fileDelete'
+    ];
+    const routeAuthTypes = routeNames.reduce((acc, routeName) => {
+        const config = routeConfig(routeName);
+        if (config?.public || config?.auth?.length === 0) {
+            acc[routeName] = [];
+        }
+        else if (config?.auth && config.auth.length > 0) {
+            acc[routeName] = config.auth;
+        }
+        else {
+            acc[routeName] = undefined;
+        }
+        return acc;
+    }, {});
+    const routeRecaptcha = routeNames.reduce((acc, routeName) => {
+        const config = routeConfig(routeName);
+        acc[routeName] = {
+            recaptcha: config?.recaptcha,
+            recaptchaAction: config?.recaptchaAction
+        };
+        return acc;
+    }, {});
+    return (server) => {
+        const { authenticate, recaptcha } = server;
+        const schema = (0, resource_schema_1.createSchema)(name, routeAuthTypes, routeRecaptcha);
+        const service = (0, context_1.injectService)(name);
+        const resourceModel = (0, context_1.injectModel)(name);
+        const routeAuth = (config) => [
+            config?.public ? undefined : authenticate(config?.auth),
+            config?.recaptcha || config?.recaptchaAction ? recaptcha : undefined
+        ].filter((v) => v !== undefined);
+        const hasFiles = Object.keys(resourceModel.config.files ?? {}).length > 0;
+        const findConfig = routeConfig('find');
+        if (!findConfig?.exclude) {
+            server.get('/:id', {
+                schema: schema.findSchema,
+                onRequest: routeAuth(findConfig),
+                config: findConfig
+            }, async (request, reply) => {
+                const response = await service.find(request.params.id);
+                return reply.send(response);
+            });
+        }
+        const queryConfig = routeConfig('query');
+        if (!queryConfig?.exclude) {
+            server.post('/query', {
+                schema: schema.querySchema,
+                onRequest: routeAuth(queryConfig),
+                config: queryConfig
+            }, async (request, reply) => {
+                const { page, size, sort, ...body } = request.body;
+                const response = await service.query(body.filter, page, size, sort);
+                return reply.send(response);
+            });
+        }
+        const aggregateConfig = routeConfig('aggregate');
+        if (!aggregateConfig?.exclude) {
+            server.post('/aggregate', {
+                schema: schema.aggregateSchema,
+                onRequest: routeAuth(aggregateConfig),
+                config: aggregateConfig
+            }, async (request, reply) => {
+                const { dateField, from, to, step, safeIncrement, ...body } = request.body;
+                const response = await service.aggregate(body.filter, body.select, dateField, from, to, step, safeIncrement);
+                return reply.send(response);
+            });
+        }
+        const createConfig = routeConfig('create');
+        if (!createConfig?.exclude) {
+            server.post('', {
+                schema: schema.createSchema,
+                onRequest: routeAuth(createConfig),
+                config: createConfig
+            }, async (request, reply) => {
+                const response = await service.create(request.body);
+                return reply.status(201).send(response);
+            });
+        }
+        const updateConfig = routeConfig('update');
+        if (!updateConfig?.exclude) {
+            server.put('/:id', {
+                schema: schema.updateSchema,
+                onRequest: routeAuth(updateConfig),
+                config: updateConfig
+            }, async (request, reply) => {
+                const response = await service.update(request.params.id, request.body);
+                return reply.send(response);
+            });
+        }
+        const deleteConfig = routeConfig('delete');
+        if (!deleteConfig?.exclude) {
+            server.delete('/:id', {
+                schema: schema.deleteSchema,
+                onRequest: routeAuth(deleteConfig),
+                config: deleteConfig
+            }, async (request, reply) => {
+                const response = await service.delete(request.params.id);
+                return reply.send(response);
+            });
+        }
+        const exportConfig = routeConfig('export');
+        if (!exportConfig?.exclude) {
+            server.post('/export', {
+                schema: schema.exportSchema,
+                onRequest: routeAuth(exportConfig),
+                config: exportConfig
+            }, async (request, reply) => {
+                const { sort, ...body } = request.body;
+                const response = await (0, context_1.inject)(export_1.ExportService).exportCsv(name, body.filter, sort);
+                return reply
+                    .type(response.mimeType)
+                    .header('Content-Disposition', `attachment; filename="${response.fileName}"`)
+                    .send(response.stream);
+            });
+        }
+        const fileUploadConfig = routeConfig('fileUpload');
+        if (hasFiles && !fileUploadConfig?.exclude && resourceModel.config.files) {
+            const config = resourceModel.config.files;
+            const maxSize = (0, utils_1.maxFileSize)(config);
+            server.post('/:id/files', {
+                schema: schema.fileUploadSchema,
+                onRequest: routeAuth(fileUploadConfig),
+                config: fileUploadConfig,
+                attachValidation: true // Disable validation because of a multipart body.
+            }, async (request, reply) => {
+                const resource = await service.find(request.params.id);
+                const parts = request.parts({ limits: { fileSize: maxSize } });
+                const files = await (0, context_1.inject)(storage_1.FileService).saveFiles(parts, resource, service.client);
+                return reply.send((0, utils_1.aggregateFiles)(files, config));
+            });
+        }
+        const fileDeleteConfig = routeConfig('fileDelete');
+        if (hasFiles && !fileDeleteConfig?.exclude && resourceModel.config.files) {
+            const config = resourceModel.config.files;
+            server.post('/:id/delete-files', {
+                schema: schema.fileDeleteSchema,
+                onRequest: routeAuth(fileDeleteConfig),
+                config: fileDeleteConfig
+            }, async (request, reply) => {
+                const resource = await service.find(request.params.id);
+                const files = await (0, context_1.inject)(storage_1.FileService).deleteFiles(request.body, resource, service.client);
+                return reply.send((0, utils_1.aggregateFiles)(files, config));
+            });
+        }
+    };
+}

package/resource/resource-schema.d.ts

@@ -0,0 +1,33 @@
+import { AuthType, RecaptchaConfig, ResourceRoutesConfig, ResourceSchemaConfig } from '@appweaver/common';
+export declare const Id: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TInteger;
+}>;
+export declare const IdString: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TString;
+}>;
+export declare const AuditData: import("@sinclair/typebox").TObject<{
+    updatedAt: import("@sinclair/typebox").TUnsafe<Date>;
+    createdAt: import("@sinclair/typebox").TUnsafe<Date>;
+    createdById: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnsafe<number | null>>;
+}>;
+export declare const QueryRequestData: import("@sinclair/typebox").TObject<{
+    filter: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+    page: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    size: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    sort: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export declare const QueryResponseData: import("@sinclair/typebox").TObject<{
+    resultCount: import("@sinclair/typebox").TNumber;
+    totalCount: import("@sinclair/typebox").TNumber;
+}>;
+export declare const AggregateRequestData: import("@sinclair/typebox").TObject<{
+    filter: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+    select: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+    dateField: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    from: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnsafe<Date>>;
+    to: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnsafe<Date>>;
+    step: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    safeIncrement: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
+export declare const AggregateResponseData: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+export declare function createSchema(name: string, routeAuthTypes: Record<keyof ResourceRoutesConfig, AuthType[] | undefined>, routeRecaptcha: Record<keyof ResourceRoutesConfig, RecaptchaConfig>): ResourceSchemaConfig;

package/resource/resource-schema.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateResponseData = exports.AggregateRequestData = exports.QueryResponseData = exports.QueryRequestData = exports.AuditData = exports.IdString = exports.Id = void 0;
+exports.createSchema = createSchema;
+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");
+const utils_1 = require("../utils");
+exports.Id = typebox_1.Type.Object({
+    id: typebox_1.Type.Integer({ minimum: 1 })
+});
+exports.IdString = typebox_1.Type.Object({
+    id: typebox_1.Type.String({ maxLength: 36 })
+});
+exports.AuditData = typebox_1.Type.Object({
+    updatedAt: (0, common_1.StringDate)(),
+    createdAt: (0, common_1.StringDate)(),
+    createdById: (0, common_1.Nullable)(typebox_1.Type.Integer({ minimum: 1, example: 1 }))
+});
+exports.QueryRequestData = typebox_1.Type.Object({
+    filter: typebox_1.Type.Optional((0, common_1.AnyJson)({ example: { field: 'value' } })),
+    page: typebox_1.Type.Optional(typebox_1.Type.Number({ minimum: 1, example: 1 })),
+    size: typebox_1.Type.Optional(typebox_1.Type.Number({ minimum: 0, maximum: 1000, example: 50 })),
+    sort: typebox_1.Type.Optional(typebox_1.Type.String({ example: '-createdAt,id' }))
+});
+exports.QueryResponseData = typebox_1.Type.Object({
+    resultCount: typebox_1.Type.Number({ example: 10 }),
+    totalCount: typebox_1.Type.Number({ example: 100 })
+});
+exports.AggregateRequestData = typebox_1.Type.Object({
+    filter: typebox_1.Type.Optional((0, common_1.AnyJson)({ example: { field: 'value' } })),
+    select: typebox_1.Type.Optional((0, common_1.AnyJson)({ example: { field: 'value' } })),
+    dateField: typebox_1.Type.Optional(typebox_1.Type.String({ example: 'createdAt' })),
+    from: typebox_1.Type.Optional((0, common_1.StringDate)()),
+    to: typebox_1.Type.Optional((0, common_1.StringDate)()),
+    step: typebox_1.Type.Optional(typebox_1.Type.Integer({ minimum: 1, example: 3600 })),
+    safeIncrement: typebox_1.Type.Optional(typebox_1.Type.Boolean({ example: true }))
+});
+exports.AggregateResponseData = typebox_1.Type.Optional((0, common_1.AnyJson)({ example: { field: 'value' } }));
+function createSchema(name, routeAuthTypes, routeRecaptcha) {
+    const resourceModel = (0, context_1.injectModel)(name);
+    const resourceName = (0, common_1.camelToSnakeCase)(name, ' ');
+    const tag = (0, common_1.plural)(name);
+    const queryRequest = typebox_1.Type.Composite([exports.QueryRequestData], {
+        $id: `${name}QueryRequest`
+    });
+    const queryResponse = typebox_1.Type.Composite([
+        exports.QueryResponseData,
+        typebox_1.Type.Object({
+            items: typebox_1.Type.Array(resourceModel.readManyModel)
+        })
+    ], { $id: `${name}QueryResponse` });
+    const aggregateRequest = typebox_1.Type.Composite([exports.AggregateRequestData], {
+        $id: `${name}AggregateRequest`
+    });
+    const aggregateResponse = typebox_1.Type.Composite([exports.AggregateResponseData], {
+        $id: `${name}AggregateResponse`
+    });
+    const exportRequest = typebox_1.Type.Composite([typebox_1.Type.Pick(exports.QueryRequestData, ['filter', 'sort'])], { $id: `${name}ExportRequest` });
+    const resourceSchemaConfig = {
+        findSchema: {
+            tags: [tag],
+            security: (0, security_1.authSchema)(routeAuthTypes['find']),
+            headers: (0, security_1.recaptchaHeaderSchema)(routeRecaptcha['find']),
+            summary: `Find ${resourceName} data`,
+            description: `Find ${resourceName} data`,
+            response: {
+                200: resourceModel.readOneModel,
+                ...errors_1.AllErrorResponses
+            },
+            params: exports.Id
+        },
+        querySchema: {
+            tags: [tag],
+            security: (0, security_1.authSchema)(routeAuthTypes['query']),
+            headers: (0, security_1.recaptchaHeaderSchema)(routeRecaptcha['query']),
+            summary: `Query ${resourceName} data`,
+            description: `Query ${resourceName} data`,
+            response: {
+                200: (0, utils_1.createSchemaModel)(queryResponse),
+                ...errors_1.AllErrorResponses
+            },
+            body: (0, utils_1.createSchemaModel)(queryRequest)
+        },
+        aggregateSchema: {
+            tags: [tag],
+            security: (0, security_1.authSchema)(routeAuthTypes['aggregate']),
+            headers: (0, security_1.recaptchaHeaderSchema)(routeRecaptcha['aggregate']),
+            summary: `Aggregate ${resourceName} data`,
+            description: `Aggregate ${resourceName} data`,
+            response: {
+                200: (0, utils_1.createSchemaModel)(aggregateResponse),
+                ...errors_1.AllErrorResponses
+            },
+            body: (0, utils_1.createSchemaModel)(aggregateRequest)
+        },
+        createSchema: {
+            tags: [tag],
+            security: (0, security_1.authSchema)(routeAuthTypes['create']),
+            headers: (0, security_1.recaptchaHeaderSchema)(routeRecaptcha['create']),
+            summary: `Create ${resourceName} data`,
+            description: `Create ${resourceName} data`,
+            response: {
+                201: resourceModel.readOneModel,
+                ...errors_1.AllErrorResponses
+            },
+            body: resourceModel.createOneModel
+        },
+        updateSchema: {
+            tags: [tag],
+            security: (0, security_1.authSchema)(routeAuthTypes['update']),
+            headers: (0, security_1.recaptchaHeaderSchema)(routeRecaptcha['update']),
+            summary: `Update ${resourceName} data`,
+            description: `Update ${resourceName} data`,
+            response: {
+                200: resourceModel.readOneModel,
+                ...errors_1.AllErrorResponses
+            },
+            body: resourceModel.updateOneModel,
+            params: exports.Id
+        },
+        deleteSchema: {
+            tags: [tag],
+            security: (0, security_1.authSchema)(routeAuthTypes['delete']),
+            headers: (0, security_1.recaptchaHeaderSchema)(routeRecaptcha['delete']),
+            summary: `Delete ${resourceName} data`,
+            description: `Delete ${resourceName} data`,
+            response: {
+                200: resourceModel.readOneModel,
+                ...errors_1.AllErrorResponses
+            },
+            params: exports.Id
+        },
+        exportSchema: {
+            tags: [tag],
+            security: (0, security_1.authSchema)(routeAuthTypes['export']),
+            headers: (0, security_1.recaptchaHeaderSchema)(routeRecaptcha['export']),
+            summary: `Export ${resourceName} data`,
+            description: `Export ${resourceName} data`,
+            response: {
+                200: {
+                    content: {
+                        'text/csv': {
+                            schema: typebox_1.Type.String({ format: 'binary' })
+                        }
+                    }
+                },
+                ...errors_1.AllErrorResponses
+            },
+            body: (0, utils_1.createSchemaModel)(exportRequest)
+        },
+        fileUploadSchema: {
+            tags: [tag],
+            security: (0, security_1.authSchema)(routeAuthTypes['fileUpload']),
+            headers: (0, security_1.recaptchaHeaderSchema)(routeRecaptcha['fileUpload']),
+            summary: `Upload ${resourceName} files`,
+            description: `Upload ${resourceName} files`,
+            consumes: ['multipart/form-data'],
+            response: {
+                200: resourceModel.filesModel,
+                ...errors_1.AllErrorResponses
+            },
+            body: resourceModel.fileUploadModel,
+            params: exports.Id
+        },
+        fileDeleteSchema: {
+            tags: [tag],
+            security: (0, security_1.authSchema)(routeAuthTypes['fileDelete']),
+            headers: (0, security_1.recaptchaHeaderSchema)(routeRecaptcha['fileDelete']),
+            summary: `Delete ${resourceName} files`,
+            description: `Delete ${resourceName} files`,
+            response: {
+                200: resourceModel.filesModel,
+                ...errors_1.AllErrorResponses
+            },
+            body: resourceModel.fileDeleteModel,
+            params: exports.Id
+        }
+    };
+    for (const resourceConfig of Object.values(resourceSchemaConfig)) {
+        resourceConfig[`x-${common_1.CONFIG_NAME}-resource`] = name;
+    }
+    return resourceSchemaConfig;
+}

package/resource/resource-service.d.ts

@@ -0,0 +1,89 @@
+import { ActionType, AggregateResponse, AggregateSelect, IResourceService, QueryResponse, Resource, ResourceClient, ResourceData } from '@appweaver/common';
+export declare abstract class ResourceService<ReadOne = Resource, ReadMany = Resource, Create = ResourceData<Resource>, Update = Partial<ResourceData<Resource>>, Query = any> implements IResourceService<ReadOne, ReadMany, Create, Update, Query> {
+    readonly modelName: string;
+    constructor(modelName: string);
+    get client(): ResourceClient;
+    find(id: number): Promise<ReadOne>;
+    query(filter?: Query, page?: number, size?: number, sort?: string): Promise<QueryResponse<ReadMany>>;
+    aggregate(filter: Query | undefined, select: AggregateSelect<ReadOne>, dateField?: string, from?: string, to?: string, step?: number, safeIncrement?: boolean): Promise<AggregateResponse<ReadOne>>;
+    create(data: Create): Promise<ReadOne>;
+    update(id: number, data: Update): Promise<ReadOne>;
+    delete(id: number): Promise<ReadOne>;
+    /**
+     * This method should be overridden with custom logic for restricting read
+     * operations on specific data for currently logged-in user and other
+     * authorization rules. The returned object will be applied as a filter on
+     * all actions (except create action) which will prevent unwanted data access
+     * and modifications. This method can also cancel current action by throwing
+     * an error, recommended is {@link HttpError } with appropriate HTTP error
+     * code.
+     *
+     * @param action The called action method on this service (find, query,
+     * aggregate, update, or delete)
+     * @param data The passed data to the called function, can be number or
+     * object. If the data is a type of number, then it represents the resource
+     * id, otherwise it depends on the action and can be one of the following:
+     *
+     * - query and aggregate -> filter object
+     * - update -> combined id and the data object (i.e. { id, ...data })
+     *
+     * For other actions (find and delete) it represents the resource id.
+     * @return The filter containing additional query restrictions.
+     */
+    protected readRestrictions(action: Exclude<ActionType, 'create'>, data: any): Promise<Query>;
+    /**
+     * This method should be overridden with custom logic for restricting write
+     * operations on specific data for currently logged-in users and other
+     * authorization rules. The returned object will be applied as a filter on
+     * all actions (create and update) to ensure that users can only modify
+     * data they are authorized to access. This method can also cancel the
+     * current action by throwing an error, with the recommended type being
+     * {@link HttpError} with the appropriate HTTP error code.
+     *
+     * @param action The called action method on this service (create or update)
+     * @param data The passed data to the called function, which should be an
+     * object representing the resource data to be created or updated. For
+     * update operations, this object will also include the resource ID.
+     *
+     * @return A partial object containing additional data restrictions to be
+     * applied, or an empty object if no restrictions are necessary.
+     */
+    protected writeRestrictions(action: 'create' | 'update', data: any): Promise<Partial<Create & Update>>;
+    /**
+     * This method should provide logic for checking the access permissions for
+     * the provided resource object. If the resource should not be accessible by
+     *  a currently authenticated user or other logic, this method should return
+     * false. Otherwise, it returns true and continues with the request execution.
+     *
+     * @param action The called action method on this service (find, query,
+     * aggregate, create, update, or delete)
+     * @param resource The resource object that is being check for access.
+     * @returns True if the access for resource is granted, false otherwise.
+     */
+    protected checkAccess(action: ActionType, resource: ReadOne): Promise<boolean>;
+    /**
+     * Constructs a query object for performing a text search on resources in the
+     * database based on the provided search text. This method will transform the
+     * search text into a format suitable for text search functionality, returning
+     * a query object that can be used to filter results.
+     *
+     * @param searchText The text string used for searching resources.
+     * @returns A query object that represents the conditions for the text
+     * search operation. This will be used by the database query methods to
+     * retrieve matching resources.
+     */
+    protected textSearchQuery(searchText: string): Query;
+    private extractTextSearchQuery;
+    private mapSortValues;
+    private mapAggregationValues;
+    private makeAggregationIterator;
+    private projectResource;
+    private projectVirtualFields;
+    private sanitizeData;
+    private mapQueryFilter;
+    private mapRelationInclusions;
+    private buildNestedInclusion;
+    private shouldIncludeRelation;
+    private mapRelationActions;
+    private createdByConnect;
+}