@appweaver/core 1.0.0

package/storage/file-service.js

@@ -0,0 +1,384 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileService = void 0;
+const common_1 = require("@appweaver/common");
+const context_1 = require("../context");
+const errors_1 = require("../errors");
+const security_1 = require("../security");
+const cache_1 = require("../cache");
+const utils_1 = require("../utils");
+class FileService {
+    /** @internal */
+    _db = (0, context_1.inject)(common_1.Database);
+    /** @internal */
+    _storage = (0, context_1.inject)(common_1.Storage);
+    /** @internal */
+    _cacheService = (0, context_1.inject)(cache_1.CacheService);
+    /**
+     * Searches for a file by its name from a database.
+     *
+     * @param {string} fileName - The name of the file to search for.
+     * @return {Promise<File>} A promise that resolves to the file object if found.
+     * @throws {HttpError} Throws an error if a database error occurs or if the file is not found.
+     */
+    async findByName(fileName) {
+        let file;
+        try {
+            file = (await this._db.client().file.findFirst({
+                where: { name: fileName }
+            }));
+        }
+        catch (e) {
+            throw new errors_1.HttpError(`File read error`, 500, e);
+        }
+        if (!file) {
+            throw new errors_1.HttpError('File does not exist', 404);
+        }
+        return file;
+    }
+    /**
+     * Streams a file from storage, handling authorization and range-based requests.
+     *
+     * @param {string} fileName - The name of the file to stream.
+     * @param {string} [range] - An optional range header specifying the byte range to stream.
+     * @return {Promise<FileStream>} A promise that resolves to a file stream object containing the content, metadata, and
+     * range details.
+     * @throws {HttpError} Throws a 404 error if the file does not exist.
+     * @throws {HttpError} Throws a 403 error if user access to the file is forbidden.
+     * @throws {HttpError} Throws a 500 error if an error occurs while reading the file from storage.
+     */
+    async stream(fileName, range) {
+        const identity = (0, security_1.currentAuthUser)();
+        const file = await this.findByName(fileName);
+        if (!file) {
+            throw new errors_1.HttpError('File does not exist', 404);
+        }
+        const policy = this.getFilePolicy(file.resourceName, file.resourceField);
+        if (!identity && policy.accessType !== 'public') {
+            throw new errors_1.HttpError('Public file access is forbidden', 403);
+        }
+        if (policy.accessType === 'private' && identity?.id !== file.createdById) {
+            throw new errors_1.HttpError('Private file access is forbidden', 403);
+        }
+        if (policy.accessType == 'protected' &&
+            file.resourceName &&
+            file.resourceId) {
+            const resourceService = (0, context_1.injectService)(file.resourceName);
+            const resource = await resourceService.find(file.resourceId);
+            if (identity && policy.canAccess?.(identity, resource, file) === false) {
+                throw new errors_1.HttpError('File access is forbidden', 403);
+            }
+        }
+        const parsedRange = (0, utils_1.parseRange)(range);
+        const start = parsedRange.start;
+        let end = parsedRange.end;
+        const fileStream = await this._storage.stream(fileName, start, end);
+        if (!fileStream) {
+            throw new errors_1.HttpError('Error reading file from storage', 500);
+        }
+        if (end === undefined || end >= fileStream.size || end >= file.sizeBytes) {
+            end = (fileStream.size ?? file.sizeBytes) - 1;
+        }
+        return {
+            content: fileStream,
+            fileName: file.name.split('/')[0],
+            mimeType: file.mimeType,
+            start,
+            end
+        };
+    }
+    /**
+     * Saves a file to storage, validates its properties, and associates it with a specific resource and client.
+     *
+     * @param {MultipartFile} data The multipart file object containing the file data, field name, filename, and metadata.
+     * @param {Resource} resource The resource object with which the file is being associated.
+     * @param {ResourceClient} client The database client responsible for handling the resource.
+     * @return {Promise<File>} A promise that resolves to the saved file object or rejects with an error if the operation
+     * fails.
+     * @throws {HttpError} Throws an error if file validation, storage, or resource association fails.
+     */
+    async saveFile(data, resource, client) {
+        const identity = (0, security_1.currentAuthUser)();
+        if (!(data.fieldname in resource)) {
+            throw new errors_1.HttpError(`File field '${data.fieldname}' does not exist on resource '${client.name}'`, 400);
+        }
+        const fileConfig = this.getFileConfig(client.name, data.fieldname);
+        const policy = this.getFilePolicy(client.name, data.fieldname);
+        if (!(0, utils_1.isValidMimeType)(data.mimetype, fileConfig.mimeType)) {
+            throw new errors_1.HttpError(`Unsupported media file type: ${data.mimetype}`, 400);
+        }
+        if (fileConfig.array) {
+            const fileCount = await this.fileCount(data.fieldname, client.name, resource.id);
+            if (fileConfig.maxCount && fileConfig.maxCount < fileCount + 1) {
+                throw new errors_1.HttpError(`Maximum number of files allowed: ${fileConfig.maxCount}`, 400);
+            }
+        }
+        let pattern;
+        if ((0, common_1.isFunction)(fileConfig.namePattern)) {
+            pattern = fileConfig.namePattern({
+                fieldName: data.fieldname,
+                fileName: data.filename,
+                encoding: data.encoding,
+                mimeType: data.mimetype,
+                bytesRead: data.file.bytesRead,
+                truncated: data.file.truncated
+            }, resource);
+        }
+        else {
+            pattern = fileConfig.namePattern;
+        }
+        let generatedName = (0, utils_1.generateFileName)(data.filename, pattern, {
+            resourceField: data.fieldname,
+            resourceName: client.name,
+            resourceId: resource.id,
+            userId: identity?.id,
+            userEmail: identity?.email
+        });
+        let nameRegenCount = 0;
+        while (await this._storage.exists(generatedName)) {
+            nameRegenCount++;
+            if (nameRegenCount === 10) {
+                throw new errors_1.HttpError('Unable to generate unique file name', 500);
+            }
+            const hash = (0, common_1.generateToken)('bytes');
+            const nameParts = generatedName.split('.');
+            if (nameParts.length > 1) {
+                const ext = nameParts.pop();
+                const base = nameParts.join('.');
+                generatedName = `${base}-${hash}.${ext}`;
+            }
+            else {
+                generatedName = `${nameParts[0]}-${hash}`;
+            }
+        }
+        const createFile = {
+            name: generatedName,
+            originalName: data.filename,
+            mimeType: data.mimetype,
+            sizeBytes: data.file.bytesRead,
+            resourceField: data.fieldname,
+            resourceName: client.name,
+            resourceId: resource.id,
+            createdById: identity?.id
+        };
+        if (identity &&
+            policy.canCreate?.(identity, resource, createFile) === false) {
+            throw new errors_1.HttpError('Creating file is forbidden', 403);
+        }
+        const fileName = await this._storage.store(generatedName, data.file);
+        if (!fileName) {
+            throw new errors_1.HttpError('Error saving file to storage', 500);
+        }
+        createFile.name = fileName;
+        // File size checks must come after storing a file due to bytesRead and
+        // truncated fields being set only after reading the full file stream.
+        const maxSizeBytes = (0, utils_1.sizeInBytes)(fileConfig.maxSize);
+        if (data.file.truncated ||
+            (maxSizeBytes > 0 && data.file.bytesRead > maxSizeBytes)) {
+            await this._storage.delete(fileName);
+            throw new errors_1.HttpError(`File size exceeded limit of ${maxSizeBytes} bytes`, 400);
+        }
+        try {
+            // Check if a resource already has a file for a single file property and
+            // delete it after successfully creating the new one.
+            let existingFile = null;
+            if (!fileConfig.array) {
+                const resourceWithFile = await client.findFirst({
+                    where: { id: resource.id },
+                    include: { [data.fieldname]: true }
+                });
+                existingFile = resourceWithFile[data.fieldname];
+            }
+            const result = await client.update({
+                where: { id: resource.id },
+                data: {
+                    [data.fieldname]: {
+                        create: createFile
+                    }
+                },
+                include: { [data.fieldname]: true }
+            });
+            if (existingFile !== null) {
+                await this.deleteSafe(existingFile.name);
+            }
+            let file = result[data.fieldname];
+            if ((0, common_1.isArray)(result[data.fieldname])) {
+                file = result[data.fieldname].find((f) => f.name === createFile.name);
+            }
+            file.url = this.buildFileUrl(file, policy);
+            common_1.logger.debug({ file }, 'File saved');
+            return file;
+        }
+        catch (e) {
+            await this.deleteSafe(fileName);
+            throw new errors_1.HttpError(`File create error`, 500, e);
+        }
+    }
+    /**
+     * Saves files received as an asynchronous iterable of multipart data.
+     *
+     * @param {AsyncIterableIterator<Multipart>} parts - The asynchronous iterable providing multipart data where each
+     * part is expected to represent a file or other data.
+     * @param {Resource} resource - The resource associated with the files being saved, providing additional contextual
+     * information.
+     * @param {ResourceClient} client - The database client responsible for handling resource-related operations, such as
+     * database interaction.
+     * @return {Promise<File[]>} A promise that resolves to an array of successfully saved files. Rejects with an error
+     * if one or more files fail to save.
+     */
+    async saveFiles(parts, resource, client) {
+        const saveActions = [];
+        for await (const part of parts) {
+            if (part.type === 'file') {
+                saveActions.push(this.saveFile(part, resource, client));
+            }
+        }
+        const saveResults = await Promise.allSettled(saveActions);
+        const savedFiles = saveResults
+            .filter((r) => r.status === 'fulfilled')
+            .map((r) => r.value);
+        const errors = saveResults
+            .filter((r) => r.status === 'rejected')
+            .map((r) => r.reason);
+        if (errors.length > 0) {
+            // Delete all successfully saved files in storage and rows in a database.
+            const deleteActions = savedFiles.map((f) => this.deleteSafe(f.name));
+            await Promise.all(deleteActions);
+            const errorMessage = errors.join('\n');
+            throw new errors_1.HttpError(`Error while saving files: ${errorMessage}`, 400);
+        }
+        await this._cacheService.invalidateCache(client.name, 'uploadFiles');
+        return savedFiles;
+    }
+    /**
+     * Deletes a file from the storage and database if it meets the specified conditions.
+     *
+     * @param {string} fileName - The name of the file to be deleted.
+     * @param {string} fieldName - The field associated with the resource to which the file belongs.
+     * @param {Resource} resource - The resource that the file is associated with.
+     * @param {ResourceClient} client - The client instance representing the resource's type.
+     * @return {Promise<File>} A promise that resolves with the deleted file information upon successful deletion.
+     * @throws {HttpError} If the file is not associated with the provided resource or client,
+     *                     if the current user does not have permission to delete the file,
+     *                     if there is an error removing the file from storage,
+     *                     or if there is an error deleting the file from the database.
+     */
+    async deleteFile(fileName, fieldName, resource, client) {
+        const currentUser = (0, security_1.currentAuthUser)();
+        const file = await this.findByName(fileName);
+        if (file.resourceId !== resource.id ||
+            file.resourceName !== client.name ||
+            file.resourceField !== fieldName) {
+            throw new errors_1.HttpError(`File does not belong to a '${client.name}' resource`, 403);
+        }
+        const policy = this.getFilePolicy(file.resourceName, file.resourceField);
+        if (currentUser &&
+            policy.canDelete?.(currentUser, resource, file) === false) {
+            throw new errors_1.HttpError('Deleting file is forbidden', 403);
+        }
+        const result = await this._storage.delete(fileName);
+        if (!result) {
+            throw new errors_1.HttpError('Error deleting file from storage', 500);
+        }
+        try {
+            const deletedFile = (await this._db.client().file.delete({
+                where: { name: fileName }
+            }));
+            deletedFile.url = this.buildFileUrl(deletedFile, policy);
+            common_1.logger.debug({ deletedFile }, 'File deleted');
+            return deletedFile;
+        }
+        catch (e) {
+            throw new errors_1.HttpError(`File delete error`, 500, e);
+        }
+    }
+    /**
+     * Deletes a list of files associated with a given resource using the provided resource client.
+     *
+     * @param {Record<string, string | string[]>} fileNames - An object where the keys correspond to file fields and the
+     * values are either a string (single file name) or an array of file names to be deleted.
+     * @param {Resource} resource - The resource instance associated with the files to be deleted.
+     * @param {ResourceClient} client - The resource a client used to handle deletion operations.
+     * @return {Promise<File[]>} A promise that resolves to an array of files that were successfully deleted. Rejects with
+     * an error if no files could be deleted.
+     */
+    async deleteFiles(fileNames, resource, client) {
+        if (Object.keys(fileNames ?? {}).length === 0) {
+            throw new errors_1.HttpError('No files for deletion are provided', 400);
+        }
+        const deleteActions = [];
+        for (const [field, value] of Object.entries(fileNames)) {
+            const names = typeof value === 'string' ? [value] : value;
+            for (const name of names) {
+                deleteActions.push(this.deleteFile(name, field, resource, client));
+            }
+        }
+        const deleteResults = await Promise.allSettled(deleteActions);
+        const deletedFiles = deleteResults
+            .filter((r) => r.status === 'fulfilled')
+            .map((r) => r.value);
+        const errors = deleteResults
+            .filter((r) => r.status === 'rejected')
+            .map((r) => r.reason);
+        if (errors.length > 0 && deletedFiles.length === 0) {
+            const errorMessage = errors.join('\n');
+            throw new errors_1.HttpError(`Error while deleting files: ${errorMessage}`, 400);
+        }
+        await this._cacheService.invalidateCache(client.name, 'deleteFiles');
+        return deletedFiles;
+    }
+    /** @internal */
+    buildFileUrl(file, policy) {
+        return `${common_1.config.APP_HOSTNAME}/files/${policy.accessType === 'public' ? 'public' : 'protected'}/${file.name}`;
+    }
+    /** @internal */
+    async deleteSafe(fileName) {
+        let success = true;
+        try {
+            const result = await this._storage.delete(fileName);
+            if (!result) {
+                success = false;
+            }
+        }
+        catch {
+            success = false;
+        }
+        try {
+            await this._db.client().file.delete({
+                where: { name: fileName }
+            });
+        }
+        catch {
+            success = false;
+        }
+        return success;
+    }
+    /** @internal */
+    async fileCount(resourceField, resourceName, resourceId) {
+        try {
+            return await this._db.client().file.count({
+                where: { resourceField, resourceName, resourceId }
+            });
+        }
+        catch (e) {
+            throw new errors_1.HttpError(`File count read error`, 500, e);
+        }
+    }
+    /** @internal */
+    getFileConfig(resourceName, resourceField) {
+        if (!resourceName || !resourceField) {
+            return {};
+        }
+        const config = (0, context_1.injectModel)(resourceName, false)?.config.files?.[resourceField] ?? {};
+        return { ...config };
+    }
+    /** @internal */
+    getFilePolicy(resourceName, resourceField) {
+        if (!resourceName || !resourceField) {
+            return {};
+        }
+        const policy = (0, context_1.injectPolicy)(resourceName, false)?.files?.[resourceField] ?? {};
+        return { ...policy };
+    }
+}
+exports.FileService = FileService;

package/storage/filesystem-storage.d.ts

@@ -0,0 +1,10 @@
+import { Readable } from 'node:stream';
+import { ContentStream, HealthCheckResult, Storage } from '@appweaver/common';
+export declare class FilesystemStorage extends Storage {
+    onInit(): Promise<void>;
+    stream(fileName: string, start?: number, end?: number): Promise<ContentStream | null>;
+    store(fileName: string, data: Readable): Promise<string | null>;
+    delete(fileName: string): Promise<boolean>;
+    exists(fileName: string): Promise<boolean>;
+    checkHealth(): Promise<HealthCheckResult>;
+}

package/storage/filesystem-storage.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilesystemStorage = void 0;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const promises_2 = require("node:stream/promises");
+const common_1 = require("@appweaver/common");
+class FilesystemStorage extends common_1.Storage {
+    /** @internal */
+    _dirPath = common_1.config.STORAGE_PATH;
+    async onInit() {
+        const directoryExists = await this.exists('');
+        if (!directoryExists) {
+            await promises_1.default.mkdir(this._dirPath, { recursive: true });
+            common_1.logger.info(`Storage directory initialized: ${this._dirPath}`);
+        }
+    }
+    async stream(fileName, start = 0, end) {
+        const filePath = `${this._dirPath}/${fileName}`;
+        try {
+            const { size } = await promises_1.default.stat(filePath);
+            const endIndex = start >= 0 && !end && end !== 0
+                ? size - 1
+                : Math.min(end ?? Number.MAX_SAFE_INTEGER, size - 1);
+            const fileReadStream = node_fs_1.default.createReadStream(filePath, {
+                start,
+                end: !Number.isNaN(endIndex) ? endIndex : undefined
+            });
+            return { stream: fileReadStream, size };
+        }
+        catch (e) {
+            common_1.logger.error(e, `Error streaming file: ${filePath}`);
+            return null;
+        }
+    }
+    async store(fileName, data) {
+        const filePath = await this.getFilePath(fileName, true);
+        try {
+            await (0, promises_2.pipeline)(data, node_fs_1.default.createWriteStream(filePath));
+            return fileName;
+        }
+        catch (e) {
+            common_1.logger.error(e, `Error storing file: ${filePath}`);
+            return null;
+        }
+    }
+    async delete(fileName) {
+        const filePath = await this.getFilePath(fileName);
+        try {
+            await promises_1.default.unlink(filePath);
+            await this.removeEmptyDirectories(node_path_1.default.dirname(filePath));
+            return true;
+        }
+        catch (e) {
+            common_1.logger.error(e, `Error deleting file: ${filePath}`);
+            return false;
+        }
+    }
+    async exists(fileName) {
+        const filePath = await this.getFilePath(fileName);
+        try {
+            await promises_1.default.access(filePath, node_fs_1.default.constants.F_OK);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    async checkHealth() {
+        try {
+            await promises_1.default.access(this._dirPath, node_fs_1.default.constants.R_OK | node_fs_1.default.constants.W_OK);
+            return { success: true };
+        }
+        catch (e) {
+            return { success: false, message: e.message };
+        }
+    }
+    /** @internal */
+    async getFilePath(fileName, mkdir = false) {
+        const filePath = `${this._dirPath}/${fileName}`;
+        if (mkdir) {
+            await this.ensureDirectoryExists(filePath);
+        }
+        return filePath;
+    }
+    /** @internal */
+    async removeEmptyDirectories(filePath) {
+        const normalizedDirPath = node_path_1.default.normalize(filePath);
+        if (!normalizedDirPath ||
+            normalizedDirPath === node_path_1.default.normalize(this._dirPath)) {
+            return;
+        }
+        try {
+            const fileStats = await promises_1.default.lstat(filePath);
+            if (!fileStats.isDirectory()) {
+                return;
+            }
+        }
+        catch {
+            return;
+        }
+        let files = await promises_1.default.readdir(filePath);
+        if (files.length > 0) {
+            const recursiveRemovalActions = files.map((file) => this.removeEmptyDirectories(node_path_1.default.join(filePath, file)));
+            await Promise.all(recursiveRemovalActions);
+            files = await promises_1.default.readdir(filePath);
+        }
+        if (files.length === 0) {
+            await promises_1.default.rmdir(filePath);
+            await this.removeEmptyDirectories(node_path_1.default.dirname(filePath));
+        }
+    }
+    /** @internal */
+    async ensureDirectoryExists(filePath) {
+        const dirname = node_path_1.default.dirname(filePath);
+        try {
+            await promises_1.default.access(dirname, node_fs_1.default.constants.F_OK);
+        }
+        catch (e) {
+            await promises_1.default.mkdir(dirname, { recursive: true });
+        }
+    }
+}
+exports.FilesystemStorage = FilesystemStorage;

package/storage/index.d.ts

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

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

package/storage/resources/file/model.d.ts

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

package/storage/resources/file/model.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@appweaver/common");
+const factory_1 = require("../../../factory");
+const context_1 = require("../../../context");
+exports.default = (0, factory_1.createModel)({
+    name: 'File',
+    scalars: {
+        name: {
+            type: 'string',
+            maxLength: 1023,
+            unique: true,
+            example: 'image_123.png'
+        },
+        originalName: {
+            type: 'string',
+            maxLength: 255,
+            example: 'image.png'
+        },
+        mimeType: {
+            type: 'string',
+            maxLength: 127
+        },
+        sizeBytes: {
+            type: 'int',
+            minimum: 0,
+            example: 1024
+        },
+        title: {
+            type: 'string',
+            maxLength: 511,
+            required: false
+        },
+        description: {
+            type: 'string',
+            maxLength: 4095,
+            required: false
+        },
+        resourceField: {
+            type: 'string',
+            maxLength: 255,
+            required: false,
+            hidden: true
+        },
+        resourceName: {
+            type: 'string',
+            maxLength: 255,
+            required: false,
+            hidden: true
+        },
+        resourceId: {
+            type: 'int',
+            minimum: 1,
+            required: false,
+            hidden: true
+        }
+    },
+    virtual: {
+        url: {
+            type: 'string',
+            input: {
+                type: 'none'
+            },
+            output: {
+                value: (file) => {
+                    const accessType = (0, context_1.injectPolicy)(file.resourceName ?? '', false)
+                        ?.files?.[file.resourceField ?? '']?.accessType;
+                    const pathPrefix = accessType === 'public' ? 'public' : 'protected';
+                    return `${common_1.config.APP_HOSTNAME}/files/${pathPrefix}/${file.name}`;
+                }
+            }
+        }
+    },
+    index: [['resourceField', 'resourceName', 'resourceId']]
+});

package/types/application-context.d.ts

@@ -0,0 +1,20 @@
+import { AbstractCtor, Ctor, IResourceService, ResourceModel, ResourcePolicyConfig, ResourceRoutes } from '@appweaver/common';
+import { Server } from './server';
+export type DefinitionMode = 'ignore' | 'append' | 'override' | 'fail';
+export type DefinitionClass<T = any> = AbstractCtor<T> | Ctor<T>;
+export type DefinitionValue = object | ((...args: any[]) => any) | Record<string, any>;
+export type DefinitionEntry = {
+    name: string | symbol;
+    value: DefinitionValue;
+};
+export type ResourceContext = {
+    models: Map<string | symbol, ResourceModel>;
+    services: Map<string | symbol, IResourceService | Ctor<IResourceService>>;
+    policies: Map<string | symbol, ResourcePolicyConfig>;
+    routes: Map<string | symbol, ResourceRoutes>;
+};
+export type ApplicationContext = {
+    server: Server | null;
+    resource: ResourceContext;
+    definitions: DefinitionEntry[];
+};

package/types/application-context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/auth.d.ts

@@ -0,0 +1,31 @@
+import { AuthScope, AuthSource } from '@appweaver/common';
+export type JwtPayload = {
+    scope: AuthScope;
+    source: AuthSource;
+    username: string;
+    sub: number;
+    iat: number;
+};
+export type AuthTokens = {
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+    refreshExpiresIn: number;
+};
+export type AuthOTTData = {
+    authUserId: number;
+    authSource: AuthSource;
+};
+export type TwoFactorAuthData = {
+    authUserId: number;
+    codeHash: string;
+    purpose: string;
+};
+export type OAuth2StateData = {
+    redirectToUrl: string;
+};
+export type UserAdditionalData = {
+    firstName: string;
+    lastName: string;
+};
+export type RegistrationDataFn<T = any> = (source: AuthSource, email: string, password?: string, additionalData?: Partial<UserAdditionalData>) => T | Promise<T>;

package/types/auth.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });