@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';
/**
 * The main provider of submission resources
 * @param configData Environment variables required to configure resources
 * @returns A provider to get access to resources
 */
declare const provider: (configData: AppConfig) => {
    configs: BaseDependencies;
    routers: {
        audit: import("express").Router;
        category: import("express").Router;
        dictionary: import("express").Router;
        submission: import("express").Router;
        submittedData: import("express").Router;
    };
    controllers: {
        audit: {
            byCategoryIdAndOrganization: import("express-serve-static-core").RequestHandler<schemaUtils.categoryOrganizationPathParams, 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, import("qs").ParsedQs, 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, import("qs").ParsedQs, 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>[], schemaUtils.dataEditRequestSchemaQueryParams, 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>>;
            getActiveByOrganization: import("express-serve-static-core").RequestHandler<schemaUtils.categoryOrganizationPathParams, unknown, object, import("qs").ParsedQs, Record<string, any>>;
            submit: import("express-serve-static-core").RequestHandler<schemaUtils.categoryPathParams, unknown, Record<string, unknown>[], schemaUtils.uploadSubmissionRequestQueryParams, 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<schemaUtils.categoryOrganizationPathParams, unknown, object, schemaUtils.dataQueryParams, Record<string, any>>;
            getSubmittedDataByQuery: import("express-serve-static-core").RequestHandler<schemaUtils.categoryOrganizationPathParams, unknown, object, schemaUtils.dataQueryParams, Record<string, any>>;
            getSubmittedDataBySystemId: import("express-serve-static-core").RequestHandler<schemaUtils.dataGetBySystemIdPathParams, unknown, object, schemaUtils.getDataQueryParams, Record<string, any>>;
        };
    };
    services: {
        audit: {
            byCategoryIdAndOrganization: (categoryId: number, organization: string, filterOptions: typeUtils.AuditFilterOptions) => Promise<{
                data: typeUtils.AuditDataResponse[];
                metadata: {
                    totalRecords: number;
                    errorMessage?: string;
                };
            }>;
        };
        category: {
            getDetails: (categoryId: number) => Promise<typeUtils.CategoryDetailsResponse | undefined>;
            listAll: () => Promise<typeUtils.ListAllCategoriesResponse[]>;
        };
        dictionary: {
            createDictionaryIfDoesNotExist: (dictionaryName: string, version: string, schemas: typeUtils.Schema[]) => 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, }: {
                categoryName: string;
                dictionaryName: string;
                dictionaryVersion: string;
                defaultCentricEntity?: string;
            }) => Promise<{
                dictionary: import("@overture-stack/lyric-data-model/models").Dictionary;
                category: import("@overture-stack/lyric-data-model/models").Category;
            }>;
        };
        submission: {
            commitSubmission: (categoryId: number, submissionId: number, username: string) => Promise<typeUtils.CommitSubmissionResult>;
            deleteActiveSubmissionById: (submissionId: number, username: string) => Promise<import("@overture-stack/lyric-data-model/models").Submission | undefined>;
            deleteActiveSubmissionEntity: (submissionId: number, username: string, filter: {
                actionType: typeUtils.SubmissionActionType;
                entityName: string;
                index: number | null;
            }) => Promise<import("@overture-stack/lyric-data-model/models").Submission | undefined>;
            getSubmissionsByCategory: (categoryId: number, paginationOptions: typeUtils.PaginationOptions, filterOptions: {
                onlyActive: boolean;
                username?: string;
                organization?: string;
            }) => Promise<{
                result: typeUtils.SubmissionSummaryResponse[];
                metadata: {
                    totalRecords: number;
                    errorMessage?: string;
                };
            }>;
            getSubmissionById: (submissionId: number) => Promise<typeUtils.SubmissionResponse | undefined>;
            getActiveSubmissionByOrganization: ({ categoryId, username, organization, }: {
                categoryId: number;
                username: string;
                organization: string;
            }) => Promise<typeUtils.SubmissionSummaryResponse | undefined>;
            getOrCreateActiveSubmission: (params: {
                username: string;
                categoryId: number;
                organization: string;
            }) => Promise<import("@overture-stack/lyric-data-model/models").Submission>;
            submit: ({ records, entityName, categoryId, organization, username, }: {
                records: Record<string, unknown>[];
                entityName: string;
                categoryId: number;
                organization: string;
                username: string;
            }) => Promise<typeUtils.CreateSubmissionResult>;
        };
        submittedData: {
            deleteSubmittedDataBySystemId: (categoryId: number, systemId: string, username: string) => Promise<{
                description: string;
                inProcessEntities: string[];
                status: typeUtils.CreateSubmissionStatus;
                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;
            }) => Promise<{
                result: typeUtils.SubmittedDataResponse[];
                metadata: {
                    totalRecords: number;
                    errorMessage?: string;
                };
            }>;
            getSubmittedDataByOrganization: (categoryId: number, organization: string, paginationOptions: typeUtils.PaginationOptions, filterOptions: {
                sqon?: import("@overture-stack/sqon-builder").SQON;
                entityName?: string[];
                view: typeUtils.ViewType;
            }) => Promise<{
                result: typeUtils.SubmittedDataResponse[];
                metadata: {
                    totalRecords: number;
                    errorMessage?: string;
                };
            }>;
            getSubmittedDataBySystemId: (categoryId: number, systemId: string, filterOptions: {
                view: typeUtils.ViewType;
            }) => Promise<{
                result: typeUtils.SubmittedDataResponse | undefined;
                metadata: {
                    errorMessage?: string;
                };
            }>;
        };
    };
    repositories: {
        audit: {
            getRecordsByCategoryIdAndOrganizationPaginated: (categoryId: number, organization: string, filterOptions: typeUtils.AuditFilterOptions) => Promise<typeUtils.AuditRepositoryRecord[]>;
            getTotalRecordsByCategoryIdAndOrganization: (categoryId: number, organization: string, filterOptions: typeUtils.AuditFilterOptions) => 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>;
        };
        submission: {
            save: (data: import("@overture-stack/lyric-data-model/models").NewSubmission) => Promise<import("@overture-stack/lyric-data-model/models").Submission>;
            getActiveSubmission: ({ categoryId, username, organization, }: {
                categoryId: number;
                username: string;
                organization: string;
            }) => Promise<import("@overture-stack/lyric-data-model/models").Submission | undefined>;
            getSubmissionById: (submissionId: number) => Promise<import("@overture-stack/lyric-data-model/models").Submission | 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<import("@overture-stack/lyric-data-model/models").Submission>;
            getSubmissionsWithRelationsByCategory: (categoryId: number, paginationOptions: typeUtils.PaginationOptions, filterOptions: {
                onlyActive: boolean;
                username?: string;
                organization?: string;
            }) => Promise<typeUtils.SubmissionSummaryRepository[] | undefined>;
            getTotalSubmissionsByCategory: (categoryId: number, filterOptions: {
                onlyActive: boolean;
                username?: string;
                organization?: string;
            }) => Promise<number>;
            getActiveSubmissionWithRelationsByOrganization: ({ categoryId, username, organization, }: {
                categoryId: number;
                username: string;
                organization: string;
            }) => Promise<typeUtils.SubmissionSummaryRepository | undefined>;
            getSubmissionWithRelationsById: (submissionId: number) => Promise<typeUtils.SubmissionSummaryRepository | undefined>;
        };
        submittedData: {
            deleteBySystemId: (params: {
                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<{
                id: number;
                data: import("@overture-stack/lectern-client").DataRecord;
                dictionaryCategoryId: number;
                entityName: string;
                isValid: boolean;
                lastValidSchemaId: number | null;
                organization: string;
                originalSchemaId: number;
                systemId: string;
                createdAt: Date | null;
                createdBy: string | null;
                updatedAt: Date | null;
                updatedBy: string | null;
            }[]>;
            save: (data: 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<import("@overture-stack/lyric-data-model/models").SubmittedData>;
            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[];
            }) => 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[];
            }) => Promise<number>;
            update: ({ submittedDataId, dataDiff, newData, oldIsValid, submissionId, }: {
                submittedDataId: number;
                dataDiff: import("@overture-stack/lyric-data-model/models").DataDiff;
                newData: Partial<import("@overture-stack/lyric-data-model/models").SubmittedData>;
                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>;
            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;
    };
};
export default provider;