@appweaver/core 1.0.0

package/database/create-client.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClient = createClient;
+const node_path_1 = __importDefault(require("node:path"));
+const common_1 = require("@appweaver/common");
+const options = {
+    transactionOptions: {
+        maxWait: common_1.config.DATABASE_TRANSACTION_MAX_WAIT,
+        timeout: common_1.config.DATABASE_TRANSACTION_TIMEOUT
+    },
+    log: common_1.config.DATABASE_LOG_EVENTS.map((e) => ({ emit: 'event', level: e }))
+};
+/**
+ * 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.
+ */
+function createClient() {
+    const dbType = (0, common_1.resolveDatabaseType)(common_1.config.DATABASE_TYPE, common_1.config.DATABASE_URL);
+    switch (dbType) {
+        case common_1.DatabaseType.Sqlite:
+            return sqliteClient();
+        case common_1.DatabaseType.PostgresSQL:
+            return postgresClient();
+        case common_1.DatabaseType.MySQL:
+            return mysqlClient();
+        case common_1.DatabaseType.SQLServer:
+            return sqlServerClient();
+        default:
+            return sqliteClient();
+    }
+}
+/**
+ * Initializes and returns an instance of the PrismaClient configured with a Better SQLite3 adapter.
+ *
+ * This method sets up a database connection using the PrismaBetterSqlite3 adapter with the provided
+ * database URL and additional options.
+ *
+ * @return {PrismaClient} A configured instance of PrismaClient for interacting with the SQLite database.
+ */
+function sqliteClient() {
+    let sqliteAdapter;
+    if (common_1.config.APP_RUNTIME === common_1.Runtime.Bun) {
+        const { PrismaLibSql } = (0, common_1.requireModule)('@prisma/adapter-libsql', true).value;
+        sqliteAdapter = PrismaLibSql;
+    }
+    else {
+        const { PrismaBetterSqlite3 } = (0, common_1.requireModule)('@prisma/adapter-better-sqlite3', true).value;
+        sqliteAdapter = PrismaBetterSqlite3;
+    }
+    const adapter = new sqliteAdapter({
+        url: common_1.config.DATABASE_URL || 'file:./sqlite.db'
+    });
+    return createPrismaClient(adapter);
+}
+/**
+ * Creates and returns an instance of PrismaClient configured with the specified options.
+ *
+ * @return {PrismaClient} An instance of PrismaClient used to interact with a PostgresSQL database.
+ */
+function postgresClient() {
+    const { PrismaPg } = (0, common_1.requireModule)('@prisma/adapter-pg', true).value;
+    const adapter = new PrismaPg({
+        connectionString: common_1.config.DATABASE_URL
+    });
+    return createPrismaClient(adapter);
+}
+/**
+ * Initializes and returns an instance of PrismaClient configured to use
+ * a MariaDB adapter with the specified database connection settings.
+ *
+ * @return {PrismaClient} A PrismaClient instance configured for MariaDB.
+ */
+function mysqlClient() {
+    const { PrismaMariaDb } = (0, common_1.requireModule)('@prisma/adapter-mariadb', true).value;
+    const dbUrl = new URL(common_1.config.DATABASE_URL);
+    const adapter = new PrismaMariaDb({
+        host: dbUrl.hostname,
+        port: parseInt(dbUrl.port || '3306', 10),
+        user: decodeURIComponent(dbUrl.username),
+        password: decodeURIComponent(dbUrl.password),
+        database: dbUrl.pathname.slice(1)
+    });
+    return createPrismaClient(adapter);
+}
+/**
+ * Creates and returns a PrismaClient configured to connect to a SQL Server database.
+ *
+ * This method uses the Prisma MSSQL adapter with the connection string from config.
+ *
+ * @return {PrismaClient} An instance of PrismaClient for interacting with the SQL Server database.
+ */
+function sqlServerClient() {
+    const { PrismaMssql } = (0, common_1.requireModule)('@prisma/adapter-mssql', true).value;
+    const adapter = new PrismaMssql(common_1.config.DATABASE_URL);
+    return createPrismaClient(adapter);
+}
+/**
+ * Creates and returns an instance of PrismaClient configured with the specified SQL driver adapter.
+ * The PrismaClient class is loaded from the configured output path relative to the root directory.
+ *
+ * @param {SqlDriverAdapterFactory} adapter - The SQL driver adapter factory used to configure the PrismaClient.
+ * @return {PrismaClient} A configured PrismaClient instance.
+ */
+function createPrismaClient(adapter) {
+    const cwd = process.cwd();
+    const mainPath = require.main?.filename || process.argv[1];
+    const relativeMainPath = mainPath.replace(`${cwd}${node_path_1.default.sep}`, '');
+    const distDirName = relativeMainPath.includes('node_modules')
+        ? 'dist'
+        : relativeMainPath.split(node_path_1.default.sep)[0];
+    const buildDirPath = (0, common_1.isTypeScriptRuntime)()
+        ? ''
+        : common_1.config.APP_BUILD_PATH || distDirName;
+    const testDirPath = !(0, common_1.isTypeScriptRuntime)() && common_1.config.APP_ENV === 'test' ? '..' : '';
+    // Construct the Prisma client path supporting multiple different ways of running
+    // application (JavaScript runtime, TypeScript runtime, tests, from CLI, ...)
+    const clientPath = node_path_1.default.join(cwd, buildDirPath, testDirPath, common_1.config.DATABASE_CLIENT_OUTPUT_DIR_PATH, 'client');
+    const { PrismaClient } = (0, common_1.requireModule)(clientPath, true).value;
+    const client = new PrismaClient({ adapter, ...options });
+    // Add configured Prisma event logging
+    for (const event of common_1.config.DATABASE_LOG_EVENTS) {
+        if (event === common_1.DatabaseEvent.Query) {
+            client.$on(event, (e) => {
+                common_1.logger.debug(e, 'Prisma query');
+            });
+        }
+        else {
+            client.$on(event, (e) => {
+                common_1.logger[event](e, `Prisma ${event} log`);
+            });
+        }
+    }
+    return client;
+}

package/database/index.d.ts

@@ -0,0 +1 @@
+export * from './prisma-database';

package/database/index.js

@@ -0,0 +1,17 @@
+"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("./prisma-database"), exports);

package/database/prisma-database.d.ts

@@ -0,0 +1,15 @@
+import { Database, HealthCheckResult } from '@appweaver/common';
+import { PrismaClient } from '../prisma/client/client';
+/**
+ * Represents a database utility class that provides methods
+ * to connect to and disconnect from the database, as well as
+ * access to the database Prisma client instance.
+ */
+export declare class PrismaDatabase extends Database {
+    onInit(): Promise<void>;
+    onDestroy(): Promise<void>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    client<T = PrismaClient>(): T;
+    checkHealth(): Promise<HealthCheckResult>;
+}

package/database/prisma-database.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaDatabase = void 0;
+const common_1 = require("@appweaver/common");
+const create_client_1 = require("./create-client");
+/**
+ * Represents a database utility class that provides methods
+ * to connect to and disconnect from the database, as well as
+ * access to the database Prisma client instance.
+ */
+class PrismaDatabase extends common_1.Database {
+    /** @internal */
+    _client;
+    async onInit() {
+        await this.connect();
+    }
+    async onDestroy() {
+        await this.disconnect();
+    }
+    async connect() {
+        if (this._client) {
+            return;
+        }
+        await this.client().$connect();
+    }
+    async disconnect() {
+        if (!this._client) {
+            return;
+        }
+        await this.client().$disconnect();
+        this._client = undefined;
+    }
+    client() {
+        return this.clientInstance();
+    }
+    async checkHealth() {
+        try {
+            await this.client().$queryRaw `SELECT 1`;
+            return { success: true };
+        }
+        catch (e) {
+            return { success: false, message: e.message };
+        }
+    }
+    /** @internal */
+    clientInstance() {
+        if (!this._client) {
+            this._client = (0, create_client_1.createClient)();
+        }
+        return this._client;
+    }
+}
+exports.PrismaDatabase = PrismaDatabase;

package/errors/error-handler.d.ts

@@ -0,0 +1,3 @@
+import { FastifyError, FastifyReply, FastifyRequest } from 'fastify';
+import { HttpError } from './http-error';
+export declare function errorHandler(err: FastifyError | HttpError, request: FastifyRequest, reply: FastifyReply): void;

package/errors/error-handler.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorHandler = errorHandler;
+function errorHandler(err, request, reply) {
+    const { message, statusCode, error, errorCode } = err;
+    if (!statusCode || statusCode >= 500) {
+        if (!error) {
+            request.log.error(err.stack);
+        }
+        else {
+            request.log.error(error);
+        }
+    }
+    const errorResponse = {
+        errorCode: errorCode || statusCode || 500,
+        message: message || 'Unknown error'
+    };
+    const contentType = reply.getHeader('Content-Type');
+    reply
+        .status(statusCode || 500)
+        .send(contentType && contentType !== 'application/json'
+        ? errorResponse.message
+        : errorResponse);
+}

package/errors/error-schema.d.ts

@@ -0,0 +1,32 @@
+export declare const ClientErrorResponse: import("@sinclair/typebox").TObject<{
+    errorCode: import("@sinclair/typebox").TInteger;
+    message: import("@sinclair/typebox").TString;
+}>;
+export declare const ServerErrorResponse: import("@sinclair/typebox").TObject<{
+    errorCode: import("@sinclair/typebox").TInteger;
+    message: import("@sinclair/typebox").TString;
+}>;
+export declare const AllErrorResponses: {
+    '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;
+                }>;
+            };
+        };
+    };
+};

package/errors/error-schema.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AllErrorResponses = exports.ServerErrorResponse = exports.ClientErrorResponse = void 0;
+const typebox_1 = require("@sinclair/typebox");
+const utils_1 = require("../utils");
+exports.ClientErrorResponse = typebox_1.Type.Object({
+    errorCode: typebox_1.Type.Integer({ example: 400 }),
+    message: typebox_1.Type.String({ example: 'Client error description' })
+}, { $id: 'ClientErrorResponse' });
+exports.ServerErrorResponse = typebox_1.Type.Object({
+    errorCode: typebox_1.Type.Integer({ example: 500 }),
+    message: typebox_1.Type.String({ example: 'Server error description' })
+}, { $id: 'ServerErrorResponse' });
+exports.AllErrorResponses = {
+    '4xx': {
+        description: 'Client error',
+        content: {
+            'application/json': {
+                schema: (0, utils_1.createSchemaModel)(exports.ClientErrorResponse)
+            }
+        }
+    },
+    '5xx': {
+        description: 'Server error',
+        content: {
+            'application/json': {
+                schema: (0, utils_1.createSchemaModel)(exports.ServerErrorResponse)
+            }
+        }
+    }
+};

package/errors/http-error.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Represents an HTTP error with additional contextual information.
+ * Extends the built-in `Error` class by including an HTTP status code,
+ * an optional error detail, and an optional error code.
+ *
+ * The error message may include additional details if the application
+ * is not running in the production environment.
+ *
+ * @class
+ * @extends Error
+ * @param {string} text - The main error message.
+ * @param {number} [statusCode=400] - The HTTP status code associated with the error.
+ * @param {unknown} [error] - Optional additional error detail, such as an error object or metadata.
+ * @param {number} [errorCode] - Optional application-specific error code.
+ */
+export declare class HttpError extends Error {
+    statusCode: number;
+    error?: unknown | undefined;
+    errorCode?: number | undefined;
+    constructor(text: string, statusCode?: number, error?: unknown | undefined, errorCode?: number | undefined);
+}

package/errors/http-error.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpError = void 0;
+const common_1 = require("@appweaver/common");
+/**
+ * Represents an HTTP error with additional contextual information.
+ * Extends the built-in `Error` class by including an HTTP status code,
+ * an optional error detail, and an optional error code.
+ *
+ * The error message may include additional details if the application
+ * is not running in the production environment.
+ *
+ * @class
+ * @extends Error
+ * @param {string} text - The main error message.
+ * @param {number} [statusCode=400] - The HTTP status code associated with the error.
+ * @param {unknown} [error] - Optional additional error detail, such as an error object or metadata.
+ * @param {number} [errorCode] - Optional application-specific error code.
+ */
+class HttpError extends Error {
+    statusCode;
+    error;
+    errorCode;
+    constructor(text, statusCode = 400, error, errorCode) {
+        super(common_1.config.APP_ENV !== common_1.Environment.Production && error
+            ? ` ${text} (${(0, common_1.errorMessage)(error)})`
+            : text);
+        this.statusCode = statusCode;
+        this.error = error;
+        this.errorCode = errorCode;
+    }
+}
+exports.HttpError = HttpError;

package/errors/index.d.ts

@@ -0,0 +1,3 @@
+export * from './error-handler';
+export * from './error-schema';
+export * from './http-error';

package/errors/index.js

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

package/events/node-events.d.ts

@@ -0,0 +1,7 @@
+import { ActionType, EventData, EventListener, Events } from '@appweaver/common';
+export declare class NodeEvents extends Events {
+    constructor();
+    onResourceEvent<T>(resourceName: string, event: ActionType, listener: EventListener<T>): string;
+    emitResourceEvent<T>(resourceName: string, event: ActionType, data: EventData<T>): boolean;
+    removeResourceEvent(listenerId: string): boolean;
+}

package/events/node-events.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeEvents = void 0;
+const common_1 = require("@appweaver/common");
+class NodeEvents extends common_1.Events {
+    /** @internal */
+    _eventListeners = {};
+    constructor() {
+        super({ captureRejections: true });
+        this.setMaxListeners(common_1.config.EVENTS_MAX_LISTENERS);
+        this.on('error', (e) => {
+            common_1.logger.error(e, 'Event handler error');
+        });
+    }
+    onResourceEvent(resourceName, event, listener) {
+        const listenerId = (0, common_1.uuid)();
+        const eventName = this.resourceEventName(resourceName, event);
+        this._eventListeners[listenerId] = { eventName, listener };
+        this.on(eventName, listener);
+        return listenerId;
+    }
+    emitResourceEvent(resourceName, event, data) {
+        return this.emit(this.resourceEventName(resourceName, event), data);
+    }
+    removeResourceEvent(listenerId) {
+        const listener = this._eventListeners[listenerId];
+        if (!listener) {
+            return false;
+        }
+        this.off(listener.eventName, listener.listener);
+        delete this._eventListeners[listenerId];
+        return true;
+    }
+    /** @internal */
+    resourceEventName(resourceName, event) {
+        return `${resourceName}.${event}`;
+    }
+}
+exports.NodeEvents = NodeEvents;

package/export/export-service.d.ts

@@ -0,0 +1,19 @@
+import { Readable } from 'node:stream';
+export type ExportStream = {
+    stream: Readable;
+    fileName: string;
+    mimeType: string;
+};
+export declare class ExportService {
+    /**
+     * Exports data as a CSV stream based on the provided filter and sort parameters.
+     * The method retrieves the data in batches and streams it in CSV format.
+     *
+     * @param {string} modelName - The resource name for which to export data.
+     * @param {Object} [filter={}] - The filter conditions to apply when retrieving the data. Default is an empty object.
+     * @param {string} [sort='-createdAt,id'] - The sorting criteria for the data. Default is `-createdAt, id`.
+     * @return {Promise<ExportStream>} A promise resolving to the export stream object, which includes the readable
+     * stream, MIME type, and file name for the CSV.
+     */
+    exportCsv(modelName: string, filter?: any, sort?: string): Promise<ExportStream>;
+}

package/export/export-service.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportService = void 0;
+const node_stream_1 = require("node:stream");
+const common_1 = require("@appweaver/common");
+const context_1 = require("../context");
+const errors_1 = require("../errors");
+const utils_1 = require("../utils");
+class ExportService {
+    /**
+     * Exports data as a CSV stream based on the provided filter and sort parameters.
+     * The method retrieves the data in batches and streams it in CSV format.
+     *
+     * @param {string} modelName - The resource name for which to export data.
+     * @param {Object} [filter={}] - The filter conditions to apply when retrieving the data. Default is an empty object.
+     * @param {string} [sort='-createdAt,id'] - The sorting criteria for the data. Default is `-createdAt, id`.
+     * @return {Promise<ExportStream>} A promise resolving to the export stream object, which includes the readable
+     * stream, MIME type, and file name for the CSV.
+     */
+    async exportCsv(modelName, filter = {}, sort = '-createdAt,id') {
+        const service = (0, context_1.injectService)(modelName);
+        let exportStream;
+        try {
+            // Initial query is also useful to expose any errors before stream start.
+            const checkResult = await service.query(filter, 1, 0, sort);
+            const totalCount = checkResult.totalCount;
+            const batchSize = common_1.config.EXPORT_BATCH_SIZE;
+            let page = 0;
+            const mapValues = (items) => this.mapProperties(modelName, items);
+            exportStream = new node_stream_1.Readable({
+                async read() {
+                    page++;
+                    try {
+                        const result = await service.query(filter, page, batchSize, sort);
+                        if (result.resultCount > 0) {
+                            const data = mapValues(result.items);
+                            this.push((0, utils_1.toCsv)(data, common_1.config.EXPORT_CSV_ADD_HEADERS ? page === 1 : false));
+                        }
+                    }
+                    catch (e) {
+                        common_1.logger.error(e, `${modelName} export error`);
+                        this.push(null);
+                        return;
+                    }
+                    if (page * batchSize >= totalCount) {
+                        this.push(null);
+                    }
+                }
+            });
+            if (common_1.config.EXPORT_CSV_ADD_SEP_ROW) {
+                exportStream.push(`SEP=${common_1.config.EXPORT_CSV_DELIMITER}\n`);
+            }
+        }
+        catch (e) {
+            throw new errors_1.HttpError(`${modelName} export error`, 500, e);
+        }
+        const fileName = this.generateExportFileName(modelName, 'csv');
+        common_1.logger.debug({ modelName, filter, fileName }, 'CSV File export');
+        return { stream: exportStream, mimeType: 'text/csv', fileName };
+    }
+    /** @internal */
+    mapProperties(resourceName, items) {
+        const properties = [];
+        for (const item of items) {
+            const property = this.mapProperty(resourceName, item);
+            properties.push(property);
+        }
+        return properties;
+    }
+    /** @internal */
+    mapProperty(resourceName, item, resourceExportConfig, parentKey = '') {
+        const resourceModel = (0, context_1.injectModel)(resourceName);
+        const readModel = resourceModel.readModel;
+        const relationsModel = resourceModel.relationsModel;
+        const filesModel = resourceModel.filesModel;
+        const exportConfig = resourceExportConfig ?? resourceModel.config.export;
+        const property = {};
+        for (const key in item) {
+            let value = item[key];
+            const modelSchema = (0, common_1.extractSchemaProperties)(readModel, key);
+            const relationSchema = (0, common_1.extractSchemaProperties)(relationsModel, key);
+            const fileSchema = (0, common_1.extractSchemaProperties)(filesModel, key);
+            if (!modelSchema &&
+                !relationSchema &&
+                !fileSchema &&
+                !(0, common_1.isCountField)(key)) {
+                // Skip mapping for non-exposed fields.
+                continue;
+            }
+            let header = parentKey ? `${parentKey}.${key}` : key;
+            const isArrayValue = (0, common_1.isArray)(value);
+            const exportField = exportConfig?.[key];
+            if (exportField) {
+                if (exportField.exclude === true) {
+                    // Skip mapping for excluded fields.
+                    continue;
+                }
+                if ((0, common_1.isString)(exportField.headerName)) {
+                    header = parentKey
+                        ? `${parentKey}.${exportField.headerName}`
+                        : exportField.headerName;
+                }
+                if (exportField.mapValue) {
+                    const mappedValues = [];
+                    // Transform value items using mapValue configuration.
+                    const subItems = isArrayValue ? value : [value];
+                    for (const subItem of subItems) {
+                        if ((0, common_1.isFunction)(exportField.mapValue)) {
+                            try {
+                                mappedValues.push(exportField.mapValue(subItem));
+                            }
+                            catch (e) {
+                                mappedValues.push('');
+                                common_1.logger.error(e, 'Export value mapping error.');
+                            }
+                        }
+                        else if (!(0, common_1.isObject)(exportField.mapValue)) {
+                            mappedValues.push(subItem?.[exportField.mapValue]);
+                        }
+                    }
+                    value = mappedValues.join(',');
+                }
+            }
+            // Recursively map relation and file fields if the value is an object.
+            if ((value && (0, common_1.isObject)(value)) || (isArrayValue && (0, common_1.isObject)(value[0]))) {
+                const relationName = (0, common_1.extractResourceName)(relationSchema ?? fileSchema);
+                if (!relationName) {
+                    continue;
+                }
+                const subItems = isArrayValue ? value : [value];
+                for (const subItem of subItems) {
+                    const mappedItem = this.mapProperty(relationName, subItem, exportField, header);
+                    for (const subKey in mappedItem) {
+                        if (subKey in property) {
+                            property[subKey] = [property[subKey], mappedItem[subKey]].join(common_1.config.EXPORT_CSV_JOIN_DELIMITER);
+                        }
+                        else {
+                            property[subKey] = mappedItem[subKey];
+                        }
+                    }
+                }
+            }
+            else {
+                property[header] = value;
+            }
+        }
+        return property;
+    }
+    /** @internal */
+    generateExportFileName(modelName, extension) {
+        return (0, utils_1.generateFileName)(`${(0, common_1.plural)(modelName)}.${extension}`, '{name}_{year}{month}{day}_{hours}{minutes}{seconds}.{extension}');
+    }
+}
+exports.ExportService = ExportService;

package/export/index.d.ts

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

package/export/index.js

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

package/factory/create-model.d.ts

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