@overture-stack/lyric/dist/src/core/provider.d.ts

Data Submission system

import { AppConfig, BaseDependencies } from '../config/config.js';
import * as auditUtils from '../utils/auditUtils.js';
import * as convertSqonToQueryUtils from '../utils/convertSqonToQuery.js';
import * as dictionarySchemaRelationUtils from '../utils/dictionarySchemaRelations.js';
import * as dictionaryUtils from '../utils/dictionaryUtils.js';
import * as errorUtils from '../utils/errors.js';
import * as schemaUtils from '../utils/schemas.js';
import * as submissionUtils from '../utils/submissionUtils.js';
import * as submittedDataUtils from '../utils/submittedDataUtils.js';
import * as typeUtils from '../utils/types.js';
import { type WorkerPoolConfigResolver } from '../workers/workerPoolManager.js';
export type ProviderOptions = {
    workerPoolConfigResolver?: WorkerPoolConfigResolver;
};
/**
 * The main provider of submission resources
 * @param configData Environment variables required to configure resources
 * @param options Optional provider-level overrides (mainly for test wiring)
 * @returns A provider to get access to resources
 */
declare const provider: (configData: AppConfig, options?: ProviderOptions) => {
    configs: BaseDependencies;
    routers: {
        audit: import("express").Router;
        category: import("express").Router;
        dictionary: import("express").Router;
        migration: import("express").Router;
        submission: import("express").Router;
        submittedData: import("express").Router;
        validator: import("express").Router;
    };
    controllers: {
        audit: {
            byCategoryIdAndOrganization: import("express-serve-static-core").RequestHandler<{
                categoryId: string;
                organization: string;
            }, unknown, object, schemaUtils.PaginationQueryParams & schemaUtils.AuditQueryParams, Record<string, any>>;
        };
        category: {
            getDetails: import("express-serve-static-core").RequestHandler<schemaUtils.CategoryPathParams, unknown, object, import("qs").ParsedQs, Record<string, any>>;
            listAll: (req: import("express").Request, res: import("express").Response, next: import("express").NextFunction) => Promise<import("express").Response<any, Record<string, any>> | undefined>;
        };
        dictionary: {
            registerDictionary: import("express-serve-static-core").RequestHandler<import("express-serve-static-core").ParamsDictionary, unknown, schemaUtils.DictionaryRegisterBodyParams, schemaUtils.DictionaryRegisterQueryParams, Record<string, any>>;
            downloadDataFileTemplates: import("express-serve-static-core").RequestHandler<{
                categoryId: string;
            }, unknown, unknown, {
                fileType?: "tsv" | "csv" | undefined;
            }, Record<string, any>>;
            getDictionaryJson: (req: import("express").Request, res: import("express").Response, next: import("express").NextFunction) => Promise<import("express").Response<any, Record<string, any>> | undefined>;
        };
        migration: {
            getMigrationById: import("express-serve-static-core").RequestHandler<schemaUtils.migrationIdPathParam, unknown, object, import("qs").ParsedQs, Record<string, any>>;
            getMigrationsByCategoryId: import("express-serve-static-core").RequestHandler<schemaUtils.CategoryPathParams, unknown, object, schemaUtils.PaginationQueryParams, Record<string, any>>;
            getMigrationRecords: import("express-serve-static-core").RequestHandler<schemaUtils.migrationIdPathParam, unknown, object, schemaUtils.MigrationDataQueryParams, Record<string, any>>;
        };
        submission: {
            commit: import("express-serve-static-core").RequestHandler<schemaUtils.submissionCommitPathParams, unknown, object, import("qs").ParsedQs, Record<string, any>>;
            delete: import("express-serve-static-core").RequestHandler<schemaUtils.submissionIdPathParam, unknown, object, schemaUtils.SubmissionDeleteQueryParams, Record<string, any>>;
            deleteEntityName: import("express-serve-static-core").RequestHandler<schemaUtils.SubmissionDeleteEntityNameParams, unknown, object, schemaUtils.SubmissionDeleteEntityNameQueryParams, Record<string, any>>;
            deleteSubmittedDataBySystemId: import("express-serve-static-core").RequestHandler<schemaUtils.DataDeleteBySystemIdPathParams, unknown, object, import("qs").ParsedQs, Record<string, any>>;
            editSubmittedData: import("express-serve-static-core").RequestHandler<schemaUtils.CategoryPathParams, unknown, Record<string, unknown>[], {
                organization: string;
                entityName: string;
            }, Record<string, any>>;
            getSubmissionsByCategory: import("express-serve-static-core").RequestHandler<schemaUtils.CategoryPathParams, unknown, object, schemaUtils.SubmissionsByCategoryQueryParams, Record<string, any>>;
            getSubmissionById: import("express-serve-static-core").RequestHandler<schemaUtils.submissionIdPathParam, unknown, object, import("qs").ParsedQs, Record<string, any>>;
            getSubmissionDetailsById: import("express-serve-static-core").RequestHandler<schemaUtils.submissionIdPathParam, unknown, object, schemaUtils.SubmissionsDetailsQueryParams, Record<string, any>>;
            getActiveByOrganization: import("express-serve-static-core").RequestHandler<{
                categoryId: string;
                organization: string;
            }, unknown, object, import("qs").ParsedQs, Record<string, any>>;
            submit: import("express-serve-static-core").RequestHandler<schemaUtils.CategoryPathParams, unknown, import("@overture-stack/lectern-client").DataRecord[], {
                organization: string;
                entityName: string;
            }, Record<string, any>>;
            submitFiles: import("express-serve-static-core").RequestHandler<schemaUtils.CategoryPathParams, unknown, {
                filename: string;
                entity: string;
            }[] | undefined, {
                organization: string;
                sync?: "true" | "false" | undefined;
            }, Record<string, any>>;
        };
        submittedData: {
            getSubmittedDataByCategory: import("express-serve-static-core").RequestHandler<schemaUtils.CategoryPathParams, unknown, object, schemaUtils.DataQueryParams, Record<string, any>>;
            getSubmittedDataByOrganization: import("express-serve-static-core").RequestHandler<{
                categoryId: string;
                organization: string;
            }, unknown, object, schemaUtils.DataQueryParams, Record<string, any>>;
            getSubmittedDataByQuery: import("express-serve-static-core").RequestHandler<{
                categoryId: string;
                organization: string;
            }, unknown, object, schemaUtils.DataQueryParams, Record<string, any>>;
            getSubmittedDataBySystemId: import("express-serve-static-core").RequestHandler<schemaUtils.DataGetBySystemIdPathParams, unknown, object, schemaUtils.GetDataQueryParams, Record<string, any>>;
            getSubmittedDataByCategoryStream: import("express-serve-static-core").RequestHandler<schemaUtils.CategoryPathParams, unknown, object, schemaUtils.DataQueryParams, Record<string, any>>;
        };
        validator: {
            existsRecord: import("express-serve-static-core").RequestHandler<schemaUtils.ValidationPathParams, unknown, object, schemaUtils.ValidationQueryParam, Record<string, any>>;
        };
    };
    services: {
        audit: {
            byCategoryIdAndOrganization: (categoryId: number, filterOptions: typeUtils.AuditFilterOptions) => Promise<import("../utils/result.js").PaginatedResult<typeUtils.AuditDataResponse>>;
        };
        category: {
            getDetails: (categoryId: number) => Promise<typeUtils.CategoryDetailsResponse | undefined>;
            listAll: () => Promise<typeUtils.ListAllCategoriesResponse[]>;
        };
        dictionary: {
            createDictionaryIfDoesNotExist: (dictionaryName: string, version: string, schemas: typeUtils.Schema[], username?: string) => Promise<import("@overture-stack/lyric-data-model/models").Dictionary>;
            fetchDictionaryByVersion: (dictionaryName: string, version: string) => Promise<dictionaryUtils.SchemasDictionary>;
            getActiveDictionaryByCategory: (categoryId: number) => Promise<import("@overture-stack/lyric-data-model/models").Dictionary | undefined>;
            register: ({ categoryName, dictionaryName, dictionaryVersion, defaultCentricEntity, username, forceRegistration, }: {
                categoryName: string;
                dictionaryName: string;
                dictionaryVersion: string;
                defaultCentricEntity?: string;
                username?: string;
                forceRegistration?: boolean;
            }) => Promise<{
                dictionary: import("@overture-stack/lyric-data-model/models").Dictionary;
                category: import("@overture-stack/lyric-data-model/models").Category;
                migrationId?: number;
            }>;
        };
        migration: {
            finalizeMigration: ({ migrationId, status, userName, }: {
                migrationId: number;
                status: Extract<typeUtils.MigrationStatus, "COMPLETED" | "FAILED">;
                userName: string;
            }) => import("../utils/result.js").AsyncResult<null, string>;
            getActiveMigrationByCategoryId: (categoryId: number) => Promise<import("../repository/dictionaryMigrationRepository.js").MigrationRecordWithRelations | null>;
            getMigrationsByCategoryId: (categoryId: number, paginationOptions: typeUtils.PaginationOptions) => Promise<import("../utils/result.js").PaginatedResult<import("../utils/migrationResponseFormatter.js").MigrationSummary>>;
            getMigrationById: (migrationId: number) => Promise<import("../utils/migrationResponseFormatter.js").MigrationSummary | null>;
            getMigrationRecords: (migrationId: number, options: {
                page: number;
                pageSize: number;
                entityNames?: string | string[];
                organizations?: string | string[];
                isInvalid?: boolean;
            }) => Promise<import("../utils/result.js").PaginatedResult<typeUtils.MigrationAuditRecord>>;
            initiateMigration: ({ categoryId, fromDictionaryId, toDictionaryId, userName, }: {
                categoryId: number;
                fromDictionaryId: number;
                toDictionaryId: number;
                userName: string;
            }) => import("../utils/result.js").AsyncResult<number, string>;
            performMigrationValidation: ({ migrationId, userName, }: {
                migrationId: number;
                userName: string;
            }) => import("../utils/result.js").AsyncResult<null, string>;
        };
        submission: {
            commitSubmission: (categoryId: number, submissionId: number, username: string) => Promise<typeUtils.CommitSubmissionResult>;
            deleteActiveSubmissionById: (submissionId: number, username: string, force: boolean) => Promise<typeUtils.DeleteSubmissionResult>;
            deleteActiveSubmissionEntity: (submissionId: number, username: string, filter: {
                actionType: typeUtils.SubmissionActionType;
                entityName: string;
                index: number | null;
            }) => Promise<typeUtils.SubmitDataResult>;
            getSubmissionsByCategory: (categoryId: number, paginationOptions: typeUtils.PaginationOptions, filterOptions: {
                onlyActive: boolean;
                username?: string;
                organization?: string;
            }) => Promise<import("../utils/result.js").PaginatedResult<typeUtils.SubmissionSummary>>;
            getSubmissionById: (submissionId: number) => Promise<typeUtils.SubmissionSummary | undefined>;
            getSubmissionDetailsById: ({ submissionId, paginationOptions, filterOptions, }: {
                submissionId: number;
                paginationOptions: typeUtils.PaginationOptions;
                filterOptions: {
                    entityNames: string[];
                    actionTypes: typeUtils.SubmissionActionType[];
                };
            }) => Promise<{
                data: import("../utils/submissionResponseParser.js").FlattenedSubmissionData[];
                errors?: import("@overture-stack/lyric-data-model/models").SubmissionRecordErrorDetails[];
            }>;
            getActiveSubmissionByOrganization: ({ categoryId, username, organization, }: {
                categoryId: number;
                username: string;
                organization: string;
            }) => Promise<typeUtils.SubmissionSummary | undefined>;
            getOrCreateActiveSubmission: (params: {
                username: string;
                categoryId: number;
                organization: string;
            }) => Promise<number>;
            submit: ({ data, categoryId, organization, username, }: {
                data: typeUtils.EntityData;
                categoryId: number;
                organization: string;
                username: string;
            }) => Promise<typeUtils.SubmitDataResult | {
                status: "UNKNOWN_CATEGORY";
                description: string;
            }>;
            submitFiles: ({ files, categoryId, organization, username, fileEntityMap, sync, }: {
                files: Express.Multer.File[];
                categoryId: number;
                organization: string;
                username: string;
                fileEntityMap?: schemaUtils.FilenameEntityPair[];
                sync?: boolean;
            }) => Promise<typeUtils.SubmitFileResult | {
                status: "UNKNOWN_CATEGORY";
                description: string;
            }>;
        };
        submittedData: {
            deleteSubmittedDataBySystemId: (categoryId: number, systemId: string, username: string) => Promise<{
                description: string;
                inProcessEntities: string[];
                status: typeUtils.ActiveSubmissionStatus;
                submissionId?: string;
            }>;
            editSubmittedData: ({ categoryId, entityName, organization, records, username, }: {
                categoryId: number;
                entityName: string;
                organization: string;
                records: Record<string, unknown>[];
                username: string;
            }) => Promise<{
                description?: string;
                submissionId?: number;
                status: string;
            }>;
            getSubmittedDataByCategory: (categoryId: number, paginationOptions: typeUtils.PaginationOptions, filterOptions: {
                entityName?: string[];
                view: typeUtils.ViewType;
                organizations?: string[];
            }) => Promise<import("../utils/result.js").PaginatedResult<typeUtils.SubmittedDataResponse>>;
            getSubmittedDataByOrganization: (categoryId: number, organization: string, paginationOptions: typeUtils.PaginationOptions, filterOptions: {
                sqon?: import("@overture-stack/sqon-builder").SQON;
                entityName?: string[];
                view: typeUtils.ViewType;
            }) => Promise<import("../utils/result.js").PaginatedResult<typeUtils.SubmittedDataResponse>>;
            getSubmittedDataBySystemId: (categoryId: number, systemId: string, filterOptions: {
                view: typeUtils.ViewType;
            }) => Promise<{
                result: typeUtils.SubmittedDataResponse | undefined;
                metadata: {
                    errorMessage?: string;
                };
            }>;
            getSubmittedDataByCategoryStream: (categoryId: number, filterOptions: {
                entityName?: string[];
                view: typeUtils.ViewType;
                organizations?: string[];
            }) => AsyncGenerator<typeUtils.SubmittedDataResponse, {
                result: [];
                metadata: {
                    totalRecords: number;
                    errorMessage?: string;
                };
            } | undefined, unknown>;
        };
        validation: {
            existsRecord: ({ categoryId, entityName, field, organization, value, }: {
                categoryId: number;
                entityName: string;
                field: string;
                organization: string;
                value: string;
            }) => Promise<boolean>;
        };
    };
    repositories: {
        audit: {
            getRecordsByCategoryIdAndOrganizationPaginated: (categoryId: number, filterOptions: typeUtils.AuditFilterOptions) => Promise<typeUtils.AuditRepositoryRecord[]>;
            getTotalRecordsByCategoryIdAndOrganization: (categoryId: number, filterOptions: Omit<typeUtils.AuditFilterOptions, "page" | "pageSize">) => Promise<number>;
        };
        category: {
            save: (data: import("@overture-stack/lyric-data-model/models").NewCategory) => Promise<import("@overture-stack/lyric-data-model/models").Category>;
            categoryIdExists: (categoryId: number) => Promise<boolean>;
            getAllCategoryNames: () => Promise<typeUtils.ListAllCategoriesResponse[]>;
            getCategoryById: (id: number) => Promise<(import("@overture-stack/lyric-data-model/models").Category & {
                activeDictionary: import("@overture-stack/lyric-data-model/models").Dictionary | null;
            }) | undefined>;
            getCategoryByName: (name: string) => Promise<import("@overture-stack/lyric-data-model/models").Category | undefined>;
            getActiveDictionaryByCategory: (categoryId: number) => Promise<(dictionaryUtils.SchemasDictionary & {
                id: number;
            }) | undefined>;
            update: (categoryId: number, newData: Partial<import("@overture-stack/lyric-data-model/models").Category>) => Promise<import("@overture-stack/lyric-data-model/models").Category>;
        };
        dictionary: {
            save: (data: import("@overture-stack/lyric-data-model/models").NewDictionary) => Promise<import("@overture-stack/lyric-data-model/models").Dictionary>;
            getDictionary: (dictionaryName: string, version: string) => Promise<import("@overture-stack/lyric-data-model/models").Dictionary | undefined>;
            getDictionaryById: (dictionaryId: number) => Promise<import("@overture-stack/lyric-data-model/models").Dictionary | undefined>;
        };
        migration: {
            save: (data: import("@overture-stack/lyric-data-model/models").NewDictionaryMigration) => Promise<number>;
            update: (migrationId: number, data: Partial<{
                status: "IN_PROGRESS" | "COMPLETED" | "FAILED";
                submissionId: number;
                id: number;
                createdAt: Date | null;
                createdBy: string | null;
                updatedAt: Date | null;
                updatedBy: string | null;
                retries: number;
            }>) => Promise<number>;
            getMigrationById: (migrationId: number) => Promise<import("../repository/dictionaryMigrationRepository.js").MigrationRecordWithRelations | undefined>;
            getMigrationsByCategoryId: (categoryId: number, paginationOptions: typeUtils.PaginationOptions, filterOptions: {
                status?: typeUtils.MigrationStatus;
                fromDictionaryId?: number;
                toDictionaryId?: number;
            }) => Promise<import("../utils/result.js").PaginatedResult<import("../repository/dictionaryMigrationRepository.js").MigrationRecordWithRelations>>;
            getMigrationAuditRecords: (migrationId: number, options: {
                page: number;
                pageSize: number;
                entityNames?: string | string[];
                organizations?: string | string[];
                isInvalid?: boolean;
            }) => Promise<import("../utils/result.js").PaginatedResult<typeUtils.MigrationAuditRecord>>;
        };
        submission: {
            save: (data: import("@overture-stack/lyric-data-model/models").NewSubmission) => Promise<number>;
            getActiveSubmissionDetails: ({ categoryId, organization, username, }: {
                categoryId: number;
                username: string;
                organization: string;
            }) => Promise<Pick<import("@overture-stack/lyric-data-model/models").Submission, "data" | "id"> | undefined>;
            getActiveSubmissionSummary: ({ categoryId, username, organization, }: {
                categoryId: number;
                username: string;
                organization: string;
            }) => Promise<typeUtils.SubmissionDataSummaryRepositoryRecord | undefined>;
            getSubmissionById: (submissionId: number) => Promise<typeUtils.SubmissionDataSummaryRepositoryRecord | undefined>;
            getSubmissionDetailsById: (submissionId: number) => Promise<typeUtils.SubmissionDataDetailsRepositoryRecord | undefined>;
            update: (submissionId: number, newData: Partial<import("@overture-stack/lyric-data-model/models").Submission>, tx?: import("drizzle-orm/pg-core").PgTransaction<import("drizzle-orm/postgres-js").PostgresJsQueryResultHKT, import("@overture-stack/lyric-data-model/models").Submission, import("drizzle-orm").ExtractTablesWithRelations<import("@overture-stack/lyric-data-model/models").Submission>>) => Promise<number>;
            getSubmissionsByCategory: (categoryId: number, paginationOptions: typeUtils.PaginationOptions, filterOptions: {
                onlyActive: boolean;
                username?: string;
                organization?: string;
            }) => Promise<typeUtils.SubmissionDataSummaryRepositoryRecord[] | undefined>;
            getTotalSubmissionsByCategory: (categoryId: number, filterOptions: {
                onlyActive: boolean;
                username?: string;
                organization?: string;
            }) => Promise<number>;
        };
        submittedData: {
            deleteBySystemId: (params: {
                diff: import("@overture-stack/lyric-data-model/models").DataDiff;
                submissionId: number;
                systemId: string;
                username: string;
            } | {
                diff: import("@overture-stack/lyric-data-model/models").DataDiff;
                submissionId: number;
                systemId: string;
                username: string;
            }[], tx?: import("drizzle-orm/pg-core").PgTransaction<import("drizzle-orm/postgres-js").PostgresJsQueryResultHKT, import("@overture-stack/lyric-data-model/models").SubmittedData, import("drizzle-orm").ExtractTablesWithRelations<import("@overture-stack/lyric-data-model/models").SubmittedData>>) => Promise<{
                systemId: string;
                data: import("@overture-stack/lectern-client").DataRecord;
                organization: string;
                entityName: string;
                id: number;
                dictionaryCategoryId: number;
                isValid: boolean;
                lastValidSchemaId: number | null;
                originalSchemaId: number;
                createdAt: Date | null;
                createdBy: string | null;
                updatedAt: Date | null;
                updatedBy: string | null;
            }[]>;
            save: (data: import("@overture-stack/lyric-data-model/models").NewSubmittedData | import("@overture-stack/lyric-data-model/models").NewSubmittedData[], tx?: import("drizzle-orm/pg-core").PgTransaction<import("drizzle-orm/postgres-js").PostgresJsQueryResultHKT, import("@overture-stack/lyric-data-model/models").SubmittedData, import("drizzle-orm").ExtractTablesWithRelations<import("@overture-stack/lyric-data-model/models").SubmittedData>>) => Promise<{
                id: number;
            } | {
                id: number;
            }[]>;
            getAllOrganizationsByCategoryId: (categoryId: number) => Promise<string[]>;
            getSubmittedDataByCategoryIdAndOrganization: (categoryId: number, organization: string) => Promise<import("@overture-stack/lyric-data-model/models").SubmittedData[]>;
            getSubmittedDataByCategoryIdPaginated: (categoryId: number, paginationOptions: typeUtils.PaginationOptions, filter?: {
                entityNames?: string[];
                organizations?: string[];
            }) => Promise<typeUtils.SubmittedDataResponse[]>;
            getSubmittedDataByCategoryIdAndOrganizationPaginated: (categoryId: number, organization: string, paginationOptions: typeUtils.PaginationOptions, filter?: {
                sql?: import("drizzle-orm").SQL;
                entityNames?: string[];
            }) => Promise<typeUtils.SubmittedDataResponse[]>;
            getTotalRecordsByCategoryIdAndOrganization: (categoryId: number, organization: string, filter?: {
                sql?: import("drizzle-orm").SQL;
                entityNames?: string[];
            }) => Promise<number>;
            getTotalRecordsByCategoryId: (categoryId: number, filter?: {
                sql?: import("drizzle-orm").SQL;
                entityNames?: string[];
                organizations?: string[];
            }) => Promise<number>;
            update: (params: {
                submittedDataId: number;
                data: Partial<import("@overture-stack/lyric-data-model/models").SubmittedData>;
                audit: {
                    dataDiff: import("@overture-stack/lyric-data-model/models").DataDiff;
                    errors?: import("@overture-stack/lectern-client").DictionaryValidationRecordErrorDetails[];
                    isMigration: boolean;
                    oldIsValid: boolean;
                    submissionId: number;
                };
            } | {
                submittedDataId: number;
                data: Partial<import("@overture-stack/lyric-data-model/models").SubmittedData>;
                audit: {
                    dataDiff: import("@overture-stack/lyric-data-model/models").DataDiff;
                    errors?: import("@overture-stack/lectern-client").DictionaryValidationRecordErrorDetails[];
                    isMigration: boolean;
                    oldIsValid: boolean;
                    submissionId: number;
                };
            }[], tx?: import("drizzle-orm/pg-core").PgTransaction<import("drizzle-orm/postgres-js").PostgresJsQueryResultHKT, import("@overture-stack/lyric-data-model/models").SubmittedData, import("drizzle-orm").ExtractTablesWithRelations<import("@overture-stack/lyric-data-model/models").SubmittedData>>) => Promise<import("@overture-stack/lyric-data-model/models").SubmittedData | import("@overture-stack/lyric-data-model/models").SubmittedData[]>;
            getSubmittedDataBySystemId: (systemId: string) => Promise<import("@overture-stack/lyric-data-model/models").SubmittedData | undefined>;
            getSubmittedDataFiltered: (organization: string, filterData: {
                entityName: string;
                dataField: string;
                dataValue: string | undefined;
            }[]) => Promise<import("@overture-stack/lyric-data-model/models").SubmittedData[]>;
        };
    };
    utils: {
        audit: typeof auditUtils;
        convertSqonToQuery: typeof convertSqonToQueryUtils;
        dictionarySchemaRelations: typeof dictionarySchemaRelationUtils;
        dictionary: typeof dictionaryUtils;
        errors: typeof errorUtils;
        schema: typeof schemaUtils;
        submission: typeof submissionUtils;
        submittedData: typeof submittedDataUtils;
        type: typeof typeUtils;
    };
    /**
     * Shuts down the worker pool. Call this on application termination to cleanly
     * terminate any running worker threads.
     *
     * @example
     * process.on('SIGTERM', async () => {
     *   await lyric.shutdown();
     *   process.exit(0);
     * });
     */
    shutdown: () => Promise<void>;
};
export default provider;