@appweaver/core 1.0.0

package/cache/eviction/lru-eviction-index.d.ts

@@ -0,0 +1,8 @@
+import { CacheEntryMeta } from '@appweaver/common';
+import { EvictionIndex } from './eviction-index';
+export declare class LruEvictionIndex implements EvictionIndex {
+    add(key: string, meta: CacheEntryMeta): void;
+    remove(key: string): void;
+    touch(key: string, meta: CacheEntryMeta): void;
+    evictionCandidates(count: number, now: number, gracePeriod: number): string[];
+}

package/cache/eviction/lru-eviction-index.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LruEvictionIndex = void 0;
+class LruEvictionIndex {
+    /** @internal */
+    _nodes = new Map();
+    /** @internal */
+    _head = null;
+    /** @internal */
+    _tail = null;
+    add(key, meta) {
+        if (this._nodes.has(key)) {
+            this.remove(key);
+        }
+        const node = {
+            key,
+            meta,
+            prev: null,
+            next: null
+        };
+        this.appendToTail(node);
+        this._nodes.set(key, node);
+    }
+    remove(key) {
+        const node = this._nodes.get(key);
+        if (!node) {
+            return;
+        }
+        this.detach(node);
+        this._nodes.delete(key);
+    }
+    touch(key, meta) {
+        const node = this._nodes.get(key);
+        if (!node) {
+            return;
+        }
+        this.detach(node);
+        this.appendToTail(node);
+    }
+    evictionCandidates(count, now, gracePeriod) {
+        const candidates = [];
+        let current = this._head;
+        while (current && candidates.length < count) {
+            if (current.meta.createdAt + gracePeriod < now) {
+                candidates.push(current.key);
+            }
+            current = current.next;
+        }
+        return candidates;
+    }
+    /** @internal */
+    appendToTail(node) {
+        node.prev = this._tail;
+        node.next = null;
+        if (this._tail) {
+            this._tail.next = node;
+        }
+        else {
+            this._head = node;
+        }
+        this._tail = node;
+    }
+    /** @internal */
+    detach(node) {
+        if (node.prev) {
+            node.prev.next = node.next;
+        }
+        else {
+            this._head = node.next;
+        }
+        if (node.next) {
+            node.next.prev = node.prev;
+        }
+        else {
+            this._tail = node.prev;
+        }
+        node.prev = null;
+        node.next = null;
+    }
+}
+exports.LruEvictionIndex = LruEvictionIndex;

package/cache/index.d.ts

@@ -0,0 +1,2 @@
+export * from './cache-service';
+export * from './caching';

package/cache/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("./cache-service"), exports);
+__exportStar(require("./caching"), exports);

package/cache/memory-cache.d.ts

@@ -0,0 +1,4 @@
+import { Cache } from './cache';
+export declare class MemoryCache extends Cache {
+    constructor();
+}

package/cache/memory-cache.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryCache = void 0;
+const common_1 = require("@appweaver/common");
+const context_1 = require("../context");
+const cache_1 = require("./cache");
+class MemoryCache extends cache_1.Cache {
+    constructor() {
+        super((0, context_1.inject)(common_1.Memory));
+    }
+}
+exports.MemoryCache = MemoryCache;

package/cache/redis-cache.d.ts

@@ -0,0 +1,4 @@
+import { Cache } from './cache';
+export declare class RedisCache extends Cache {
+    constructor();
+}

package/cache/redis-cache.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisCache = void 0;
+const common_1 = require("@appweaver/common");
+const context_1 = require("../context");
+const cache_1 = require("./cache");
+class RedisCache extends cache_1.Cache {
+    constructor() {
+        super((0, context_1.inject)(common_1.Redis));
+    }
+}
+exports.RedisCache = RedisCache;

package/context/context.d.ts

@@ -0,0 +1,2 @@
+import { ApplicationContext } from '../types';
+export declare const context: ApplicationContext;

package/context/context.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.context = void 0;
+exports.context = {
+    server: null,
+    resource: {
+        models: new Map(),
+        services: new Map(),
+        policies: new Map(),
+        routes: new Map()
+    },
+    definitions: []
+};

package/context/dependency-injection.d.ts

@@ -0,0 +1,98 @@
+import { ConditionalOptional, FunctionType, IResourceService, ResourceModel, ResourcePolicyConfig, ResourceRoutes } from '@appweaver/common';
+import { DefinitionClass, DefinitionEntry, DefinitionMode, DefinitionValue } from '../types';
+/**
+ * Defines a resource or a definition value within the application context.
+ *
+ * This method supports various resource models, services, routes, and policies,
+ * determining whether to add or override the definition in the application context
+ * based on the provided mode.
+ *
+ * @param {DefinitionValue} value The resource or definition value to be registered.
+ * @param {string | symbol | DefinitionClass | FunctionType | undefined} nameOrClass Optional name or class reference
+ * for the definition. If not provided, the name is inferred from the resource or its constructor.
+ * @param mode Determines how the definition should be treated:
+ *             'ignore' - Adds only if the definition doesn’t already exist.
+ *             'override' - Replaces an existing definition if it matches the name.
+ *             Defaults to 'ignore'.
+ * @return void
+ */
+export declare function define<T = DefinitionValue, S extends T = T>(value: DefinitionValue, nameOrClass?: string | symbol | DefinitionClass<S> | FunctionType, mode?: DefinitionMode): void;
+/**
+ * Loads a class from the specified path, resolves its constructor, and defines it with the provided definition.
+ *
+ * @param {string} baseDir - The base directory used to resolve relative and local class paths.
+ * @param {string} classPath - The path to the module to be loaded. Can be a relative path (`../services/example`),
+ * project source path (`@/features/services/example`), or node_modules package (`@appweaver/core/service/example`).
+ * @param {DefinitionClass} [definition] - An optional definition object used to define the loaded module.
+ * @param {boolean} [required=true] - Indicates whether the module is required. If true, an error is thrown on failure;
+ *                                    otherwise, a warning is logged.
+ * @return This function does not return a value. It loads a module and defines it if successful.
+ */
+export declare function loadProvider(baseDir: string, classPath: string, definition?: DefinitionClass, required?: boolean): void;
+/**
+ * Retrieves a definition from the application context based on the provided name.
+ * The method handles specific naming conventions for models, services, routes, and policies,
+ * and attempts to resolve the appropriate definition. Throws an error if the definition is
+ * not found, and it is marked as required.
+ *
+ * @param {string | symbol | DefinitionClass | FunctionType} nameOrClass - The name or class of the definition to retrieve.
+ *                                        Naming conventions such as suffixes 'Model', 'Service', 'Routes', or 'Policy'
+ *                                        are supported.
+ * @param {boolean} [required=true] - Indicates whether the definition is required. If true
+ *                                     and the definition is not found, an error is thrown.
+ * @return T - The resolved definition, typed as `T`. Will be `undefined` if the definition
+ *               is not found and `required` is set to `false`.
+ */
+export declare function inject<T = DefinitionValue, R extends boolean = true>(nameOrClass: string | symbol | DefinitionClass<T> | FunctionType, required?: R): ConditionalOptional<R, T>;
+/**
+ * Injects all definitions that match the specified name or class.
+ *
+ * @param {string | symbol | DefinitionClass | FunctionType} nameOrClass The name of the definition or the
+ *                                                            class constructor to find matching definitions.
+ * @return {[]} An array of definitions that match the provided name or class.
+ */
+export declare function injectAll<T = DefinitionValue>(nameOrClass: string | symbol | DefinitionClass<T> | FunctionType): T[];
+/**
+ * Injects all definitions that satisfy the specified search function criteria.
+ *
+ * @param {function(DefinitionValue): boolean} searchFunction - A callback function used to filter definitions.
+ *                                                              It should return true for definitions that match the desired criteria.
+ * @return {[]} An array of definitions that meet the criteria specified by the search function.
+ */
+export declare function injectAllWhere<T = DefinitionValue>(searchFunction: (definition: DefinitionEntry) => boolean): T[];
+/**
+ * Injects a model from the application context based on the provided model name.
+ * Throws an error if the model is not found and the required flag is set to true.
+ *
+ * @param {string} name - The name of the model to inject.
+ * @param {boolean} [required=true] - Indicates whether the model is required. If true, an error is thrown when the model is not found.
+ * @return {ResourceModel} The injected model from the application context.
+ */
+export declare function injectModel<T = ResourceModel, R extends boolean = true>(name: string, required?: R): ConditionalOptional<R, T>;
+/**
+ * Injects and retrieves a service instance from the application context based on the provided model name.
+ *
+ * @param {string} modelName - The name of the model whose service needs to be injected.
+ * @param {boolean} [required=true] - Indicates if the service is mandatory. If true and the service is not available, an error is thrown.
+ * @return {IResourceService} The service instance corresponding to the specified model name.
+ * @throws {Error} If the service cannot be found in the application context and `required` is true.
+ */
+export declare function injectService<T = IResourceService, R extends boolean = true>(modelName: string, required?: R): ConditionalOptional<R, T>;
+/**
+ * Injects a route into the application context based on the provided route name.
+ *
+ * @param {string} modelName - The name of the model whose route to retrieve from the application context.
+ * @param {boolean} [required=true] - Specifies whether the route is mandatory. If true and the route is not found, an error will be thrown.
+ * @return {ResourceRoutes} The retrieved route configuration.
+ * @throws {Error} If the route with the specified name is not found, and the `required` parameter is set to true.
+ */
+export declare function injectRoutes<R extends boolean = true>(modelName: string, required?: R): ConditionalOptional<R, ResourceRoutes>;
+/**
+ * Injects a policy configuration from the application context by its name.
+ *
+ * @param {string} modelName - The name of the model whose policy to retrieve.
+ * @param {boolean} [required=true] - Indicates whether the policy is required. If true and the policy does not exist, an error is thrown.
+ * @return {ResourcePolicyConfig} The policy configuration object associated with the provided name.
+ * @throws {Error} If the policy is required and not found in the application context.
+ */
+export declare function injectPolicy<R extends boolean = true>(modelName: string, required?: R): ConditionalOptional<R, ResourcePolicyConfig>;

package/context/dependency-injection.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.define = define;
+exports.loadProvider = loadProvider;
+exports.inject = inject;
+exports.injectAll = injectAll;
+exports.injectAllWhere = injectAllWhere;
+exports.injectModel = injectModel;
+exports.injectService = injectService;
+exports.injectRoutes = injectRoutes;
+exports.injectPolicy = injectPolicy;
+const common_1 = require("@appweaver/common");
+const context_1 = require("./context");
+/**
+ * Defines a resource or a definition value within the application context.
+ *
+ * This method supports various resource models, services, routes, and policies,
+ * determining whether to add or override the definition in the application context
+ * based on the provided mode.
+ *
+ * @param {DefinitionValue} value The resource or definition value to be registered.
+ * @param {string | symbol | DefinitionClass | FunctionType | undefined} nameOrClass Optional name or class reference
+ * for the definition. If not provided, the name is inferred from the resource or its constructor.
+ * @param mode Determines how the definition should be treated:
+ *             'ignore' - Adds only if the definition doesn’t already exist.
+ *             'override' - Replaces an existing definition if it matches the name.
+ *             Defaults to 'ignore'.
+ * @return void
+ */
+function define(value, nameOrClass, mode = 'ignore') {
+    const definitionName = (0, common_1.isString)(nameOrClass) || (0, common_1.isSymbol)(nameOrClass)
+        ? nameOrClass
+        : (nameOrClass?.name ??
+            value[common_1.RESOURCE_NAME] ??
+            value.name ??
+            value.constructor?.name);
+    if ((0, common_1.isResourceModel)(value)) {
+        if (shouldAddDefinition(context_1.context.resource.models, definitionName, mode)) {
+            context_1.context.resource.models.set(definitionName, value);
+        }
+    }
+    else if ((0, common_1.isResourceService)(value)) {
+        if (shouldAddDefinition(context_1.context.resource.services, definitionName, mode)) {
+            context_1.context.resource.services.set(definitionName, value);
+        }
+    }
+    else if ((0, common_1.isResourceRoutes)(value)) {
+        if (shouldAddDefinition(context_1.context.resource.routes, definitionName, mode)) {
+            context_1.context.resource.routes.set(definitionName, value);
+        }
+    }
+    else if ((0, common_1.isResourcePolicy)(value)) {
+        if (shouldAddDefinition(context_1.context.resource.policies, definitionName, mode)) {
+            context_1.context.resource.policies.set(definitionName, value);
+        }
+    }
+    else {
+        const shouldAdd = shouldAddDefinition(context_1.context.definitions, definitionName, mode);
+        if (shouldAdd) {
+            const index = mode === 'override'
+                ? context_1.context.definitions.findIndex((def) => def.name === definitionName)
+                : -1;
+            if (index > -1) {
+                context_1.context.definitions.splice(index, 1, { name: definitionName, value });
+            }
+            else {
+                context_1.context.definitions.push({ name: definitionName, value });
+            }
+        }
+    }
+}
+/**
+ * Loads a class from the specified path, resolves its constructor, and defines it with the provided definition.
+ *
+ * @param {string} baseDir - The base directory used to resolve relative and local class paths.
+ * @param {string} classPath - The path to the module to be loaded. Can be a relative path (`../services/example`),
+ * project source path (`@/features/services/example`), or node_modules package (`@appweaver/core/service/example`).
+ * @param {DefinitionClass} [definition] - An optional definition object used to define the loaded module.
+ * @param {boolean} [required=true] - Indicates whether the module is required. If true, an error is thrown on failure;
+ *                                    otherwise, a warning is logged.
+ * @return This function does not return a value. It loads a module and defines it if successful.
+ */
+function loadProvider(baseDir, classPath, definition, required = true) {
+    const { value, error } = (0, common_1.loadModule)(baseDir, classPath);
+    // Handle errors or missing values for both required and optional modules
+    if (!value || error) {
+        const msg = `Loading '${classPath}' module failed`;
+        if (required) {
+            common_1.logger.error(error, msg);
+            throw error ?? new Error(msg);
+        }
+        common_1.logger.warn(error, msg);
+        return;
+    }
+    // Extract class constructor from the exported value and add it to definitions
+    const ctor = Object.values(value).find((exportedValue) => (0, common_1.isConstructor)(exportedValue));
+    // Define the first found class constructor, if no constructor found then
+    // define anything that was first exported from this file
+    define(ctor ?? Object.values(value)[0], definition);
+}
+/**
+ * Retrieves a definition from the application context based on the provided name.
+ * The method handles specific naming conventions for models, services, routes, and policies,
+ * and attempts to resolve the appropriate definition. Throws an error if the definition is
+ * not found, and it is marked as required.
+ *
+ * @param {string | symbol | DefinitionClass | FunctionType} nameOrClass - The name or class of the definition to retrieve.
+ *                                        Naming conventions such as suffixes 'Model', 'Service', 'Routes', or 'Policy'
+ *                                        are supported.
+ * @param {boolean} [required=true] - Indicates whether the definition is required. If true
+ *                                     and the definition is not found, an error is thrown.
+ * @return T - The resolved definition, typed as `T`. Will be `undefined` if the definition
+ *               is not found and `required` is set to `false`.
+ */
+function inject(nameOrClass, required = true) {
+    let definition;
+    let name;
+    if ((0, common_1.isString)(nameOrClass)) {
+        name = nameOrClass;
+        if (name.endsWith('Model')) {
+            definition = context_1.context.resource.models.get(name.replace(/Model$/, ''));
+        }
+        else if (name.endsWith('Service')) {
+            definition = context_1.context.resource.services.get(name.replace(/Service$/, ''));
+        }
+        else if (name.endsWith('Routes')) {
+            definition = context_1.context.resource.routes.get(name.replace(/Routes$/, ''));
+        }
+        else if (name.endsWith('Policy')) {
+            definition = context_1.context.resource.policies.get(name.replace(/Policy$/, ''));
+        }
+        else {
+            definition = findFirstDefinition(name);
+        }
+    }
+    else {
+        name = (0, common_1.isSymbol)(nameOrClass) ? nameOrClass : nameOrClass.name;
+        definition = findFirstDefinition(name);
+    }
+    if (!definition && required) {
+        throw new Error(`Definition '${String(name)}' is not defined in the application context`);
+    }
+    return checkClassAndInit(nameOrClass, definition);
+}
+/**
+ * Injects all definitions that match the specified name or class.
+ *
+ * @param {string | symbol | DefinitionClass | FunctionType} nameOrClass The name of the definition or the
+ *                                                            class constructor to find matching definitions.
+ * @return {[]} An array of definitions that match the provided name or class.
+ */
+function injectAll(nameOrClass) {
+    const name = (0, common_1.isString)(nameOrClass) || (0, common_1.isSymbol)(nameOrClass)
+        ? nameOrClass
+        : nameOrClass.name;
+    const defs = context_1.context.definitions.filter((def) => def.name === name);
+    return defs.map((def) => checkClassAndInit(def.name, def.value));
+}
+/**
+ * Injects all definitions that satisfy the specified search function criteria.
+ *
+ * @param {function(DefinitionValue): boolean} searchFunction - A callback function used to filter definitions.
+ *                                                              It should return true for definitions that match the desired criteria.
+ * @return {[]} An array of definitions that meet the criteria specified by the search function.
+ */
+function injectAllWhere(searchFunction) {
+    const defs = context_1.context.definitions.filter(searchFunction);
+    return defs.map((def) => checkClassAndInit(def.name, def.value));
+}
+/**
+ * Injects a model from the application context based on the provided model name.
+ * Throws an error if the model is not found and the required flag is set to true.
+ *
+ * @param {string} name - The name of the model to inject.
+ * @param {boolean} [required=true] - Indicates whether the model is required. If true, an error is thrown when the model is not found.
+ * @return {ResourceModel} The injected model from the application context.
+ */
+function injectModel(name, required = true) {
+    const model = context_1.context.resource.models.get(name);
+    if (!model && required) {
+        throw new Error(`Model '${name}' is not defined in the application context`);
+    }
+    return model;
+}
+/**
+ * Injects and retrieves a service instance from the application context based on the provided model name.
+ *
+ * @param {string} modelName - The name of the model whose service needs to be injected.
+ * @param {boolean} [required=true] - Indicates if the service is mandatory. If true and the service is not available, an error is thrown.
+ * @return {IResourceService} The service instance corresponding to the specified model name.
+ * @throws {Error} If the service cannot be found in the application context and `required` is true.
+ */
+function injectService(modelName, required = true) {
+    const service = context_1.context.resource.services.get(modelName);
+    if (!service && required) {
+        throw new Error(`Service for model '${modelName}' is not defined in the application context`);
+    }
+    return checkClassAndInit(modelName, service);
+}
+/**
+ * Injects a route into the application context based on the provided route name.
+ *
+ * @param {string} modelName - The name of the model whose route to retrieve from the application context.
+ * @param {boolean} [required=true] - Specifies whether the route is mandatory. If true and the route is not found, an error will be thrown.
+ * @return {ResourceRoutes} The retrieved route configuration.
+ * @throws {Error} If the route with the specified name is not found, and the `required` parameter is set to true.
+ */
+function injectRoutes(modelName, required = true) {
+    const routes = context_1.context.resource.routes.get(modelName);
+    if (!routes && required) {
+        throw new Error(`Routes for model '${modelName}' are not defined in the application context`);
+    }
+    return routes;
+}
+/**
+ * Injects a policy configuration from the application context by its name.
+ *
+ * @param {string} modelName - The name of the model whose policy to retrieve.
+ * @param {boolean} [required=true] - Indicates whether the policy is required. If true and the policy does not exist, an error is thrown.
+ * @return {ResourcePolicyConfig} The policy configuration object associated with the provided name.
+ * @throws {Error} If the policy is required and not found in the application context.
+ */
+function injectPolicy(modelName, required = true) {
+    const policy = context_1.context.resource.policies.get(modelName);
+    if (!policy && required) {
+        throw new Error(`Policy for model '${modelName}' is not defined in the application context`);
+    }
+    return policy;
+}
+/**
+ * Checks the existence of a definition in the context store and returns if it should be added or ignored.
+ *
+ * @param {Map<string | symbol, any> | DefinitionEntry[]} store - The storage object or array where definitions are maintained.
+ * @param {string | symbol} name - The name of the definition to check.
+ * @param {boolean} mode - How to resolve already defined definitions in context.
+ * @return {boolean} Returns true if definition exists, false otherwise.
+ */
+function shouldAddDefinition(store, name, mode) {
+    if ((((0, common_1.isArray)(store) && findFirstDefinition(name)) ||
+        (!(0, common_1.isArray)(store) && store.has(name))) &&
+        !['append', 'override'].includes(mode)) {
+        const msg = `Definition '${String(name)}' is already present in the application context.`;
+        if (mode === 'fail') {
+            throw new Error(msg);
+        }
+        common_1.logger.warn(`${msg} Use 'append' or 'override' to remove this warning.`);
+        return false;
+    }
+    return true;
+}
+/**
+ * Finds the first definition object that matches the given name.
+ *
+ * @param {string | symbol} name - The name of the definition to search for.
+ * @return {DefinitionValue|undefined} The first matching definition if found, otherwise undefined.
+ */
+function findFirstDefinition(name) {
+    return context_1.context.definitions.find((def) => def.name === name)?.value;
+}
+/**
+ * Checks the provided class or definition and initializes it if necessary.
+ *
+ * @param {string | symbol | DefinitionClass | FunctionType} nameOrClass - The name or class to evaluate and potentially initialize.
+ * @param {DefinitionValue} [value] - The value to check and initialize if it is a constructor.
+ * @return {DefinitionValue | undefined} The initialized value or undefined if no initialization was performed.
+ */
+function checkClassAndInit(nameOrClass, value) {
+    if (value && (0, common_1.isConstructor)(value)) {
+        const instance = new value();
+        if (instance) {
+            define(instance, nameOrClass, 'override');
+            return instance;
+        }
+    }
+    return value;
+}

package/context/index.d.ts

@@ -0,0 +1,2 @@
+export * from './context';
+export * from './dependency-injection';

package/context/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("./context"), exports);
+__exportStar(require("./dependency-injection"), exports);

package/database/create-client.d.ts

@@ -0,0 +1,11 @@
+import { PrismaClient } from '../prisma/client/client';
+/**
+ * Creates and returns a PrismaClient instance based on the configured database type.
+ *
+ * The database type is determined by the `DATABASE_TYPE` configuration value or,
+ * if unspecified, by parsing the `DATABASE_URL` configuration.
+ * Supported database types include SQLite, PostgresSQL, and MySQL.
+ *
+ * @return {PrismaClient} A PrismaClient instance configured for the selected database type.
+ */
+export declare function createClient(): PrismaClient;