@revisium/endpoint 0.9.0

package/dist/endpoint-microservice/core-api/core-api.module.d.ts

@@ -0,0 +1,2 @@
+export declare class CoreApiModule {
+}

package/dist/endpoint-microservice/core-api/core-api.module.js

@@ -0,0 +1,25 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreApiModule = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const internal_core_api_service_1 = require("./internal-core-api.service");
+const proxy_core_api_service_1 = require("./proxy-core-api.service");
+const database_module_1 = require("../database/database.module");
+let CoreApiModule = class CoreApiModule {
+};
+exports.CoreApiModule = CoreApiModule;
+exports.CoreApiModule = CoreApiModule = __decorate([
+    (0, common_1.Module)({
+        imports: [config_1.ConfigModule, database_module_1.DatabaseModule],
+        providers: [internal_core_api_service_1.InternalCoreApiService, proxy_core_api_service_1.ProxyCoreApiService],
+        exports: [internal_core_api_service_1.InternalCoreApiService, proxy_core_api_service_1.ProxyCoreApiService],
+    })
+], CoreApiModule);
+//# sourceMappingURL=core-api.module.js.map

package/dist/endpoint-microservice/core-api/core-api.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-api.module.js","sourceRoot":"","sources":["../../../src/endpoint-microservice/core-api/core-api.module.ts"],"names":[],"mappings":";;;;;;;;;AAAA,2CAAwC;AACxC,2CAA8C;AAC9C,2EAAsG;AACtG,qEAAgG;AAChG,iEAAoF;AAO7E,IAAM,aAAa,GAAnB,MAAM,aAAa;CAAG,CAAA;AAAhB,sCAAa;wBAAb,aAAa;IALzB,IAAA,eAAM,EAAC;QACN,OAAO,EAAE,CAAC,qBAAY,EAAE,gCAAc,CAAC;QACvC,SAAS,EAAE,CAAC,kDAAsB,EAAE,4CAAmB,CAAC;QACxD,OAAO,EAAE,CAAC,kDAAsB,EAAE,4CAAmB,CAAC;KACvD,CAAC;GACW,aAAa,CAAG"}

package/dist/endpoint-microservice/core-api/generated/api.d.ts

@@ -0,0 +1,390 @@
+export interface LoginDto {
+    emailOrUsername: string;
+    password: string;
+}
+export interface LoginResponse {
+    accessToken: string;
+}
+export interface CreateUserDto {
+    email?: string;
+    username?: string;
+    roleId: 'systemAdmin' | 'systemFullApiRead' | 'systemUser';
+    password: string;
+}
+export interface ProjectModel {
+    id: string;
+    organizationId: string;
+    createdAt: string;
+    name: string;
+}
+export interface ProjectModelEdgeType {
+    cursor: string;
+    node: ProjectModel;
+}
+export interface PageInfo {
+    endCursor?: string;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    startCursor?: string;
+}
+export interface ProjectsConnection {
+    edges: ProjectModelEdgeType[];
+    totalCount: number;
+    pageInfo: PageInfo;
+}
+export interface CreateProjectDto {
+    projectName: string;
+    branchName?: string;
+}
+export interface UserModel {
+    id: string;
+    username?: string;
+}
+export interface RoleModel {
+    id: string;
+    name: string;
+}
+export interface UsersOrganizationModel {
+    id: string;
+    user: UserModel;
+    role: RoleModel;
+}
+export interface UsersOrganizationModelEdgeType {
+    cursor: string;
+    node: UsersOrganizationModel;
+}
+export interface UsersOrganizationConnection {
+    edges: UsersOrganizationModelEdgeType[];
+    totalCount: number;
+    pageInfo: PageInfo;
+}
+export interface AddUserToOrganizationDto {
+    userId: string;
+    roleId: 'organizationOwner' | 'organizationAdmin' | 'developer' | 'editor' | 'reader';
+}
+export interface RemoveUserFromOrganizationDto {
+    userId: string;
+}
+export interface BranchModel {
+    id: string;
+    projectId: string;
+    createdAt: string;
+    isRoot: boolean;
+    name: string;
+}
+export interface BranchModelEdgeType {
+    cursor: string;
+    node: BranchModel;
+}
+export interface BranchesConnection {
+    edges: BranchModelEdgeType[];
+    totalCount: number;
+    pageInfo: PageInfo;
+}
+export interface UsersProjectModel {
+    id: string;
+    user: UserModel;
+    role: RoleModel;
+}
+export interface UsersProjectModelEdgeType {
+    cursor: string;
+    node: UsersProjectModel;
+}
+export interface UsersProjectConnection {
+    edges: UsersProjectModelEdgeType[];
+    totalCount: number;
+    pageInfo: PageInfo;
+}
+export interface AddUserToProjectDto {
+    userId: string;
+    roleId: 'developer' | 'editor' | 'reader';
+}
+export interface Id {
+    id: string;
+}
+export interface ParentBranchResponse {
+    branch: Id;
+    revision: Id;
+}
+export interface RevisionModel {
+    id: string;
+    createdAt: string;
+    isDraft: boolean;
+    isHead: boolean;
+}
+export interface RevisionModelEdgeType {
+    cursor: string;
+    node: RevisionModel;
+}
+export interface RevisionsConnection {
+    edges: RevisionModelEdgeType[];
+    totalCount: number;
+    pageInfo: PageInfo;
+}
+export interface CreateRevisionDto {
+    comment?: string;
+}
+export interface ChildBranchResponse {
+    branch: Id;
+    revision: Id;
+}
+export interface TableModel {
+    versionId: string;
+    id: string;
+    createdAt: string;
+    readonly: boolean;
+}
+export interface TableModelEdgeType {
+    cursor: string;
+    node: TableModel;
+}
+export interface TablesConnection {
+    edges: TableModelEdgeType[];
+    totalCount: number;
+    pageInfo: PageInfo;
+}
+export interface EndpointModel {
+    id: string;
+    createdAt: string;
+    type: 'GRAPHQL' | 'REST_API';
+}
+export interface CreateBranchByRevisionDto {
+    branchName: string;
+}
+export interface CreateEndpointDto {
+    type: 'GRAPHQL' | 'REST_API';
+}
+export interface CreateTableDto {
+    tableId: string;
+    schema: object;
+}
+export interface CreateTableResponse {
+    branch: BranchModel;
+    table: TableModel;
+}
+export interface RowModel {
+    versionId: string;
+    id: string;
+    createdAt: string;
+    readonly: boolean;
+    data: object;
+}
+export interface RowModelEdgeType {
+    cursor: string;
+    node: RowModel;
+}
+export interface RowsConnection {
+    edges: RowModelEdgeType[];
+    totalCount: number;
+    pageInfo: PageInfo;
+}
+export interface CreateRowDto {
+    rowId: string;
+    data: object;
+}
+export interface CreateRowResponse {
+    table: TableModel;
+    previousVersionTableId: string;
+    row: RowModel;
+}
+export interface UpdateTableDto {
+    patches: object[];
+}
+export interface UpdateTableResponse {
+    table?: TableModel;
+    previousVersionTableId: string;
+}
+export interface RemoveRowResponse {
+    branch: BranchModel;
+    table?: TableModel;
+    previousVersionTableId?: string;
+}
+export interface UpdateRowDto {
+    data: object;
+}
+export interface UpdateRowResponse {
+    table?: TableModel;
+    previousVersionTableId?: string;
+    row?: RowModel;
+    previousVersionRowId?: string;
+}
+export interface ProjectsParams {
+    first: number;
+    after?: string;
+    organizationId: string;
+}
+export interface CreateProjectParams {
+    fromRevisionId: string;
+    organizationId: string;
+}
+export interface UsersOrganizationParams {
+    first: number;
+    after?: string;
+    organizationId: string;
+}
+export interface BranchesParams {
+    first: number;
+    after?: string;
+    organizationId: string;
+    projectName: string;
+}
+export interface UsersProjectParams {
+    first: number;
+    after?: string;
+    organizationId: string;
+    projectName: string;
+}
+export interface RevisionsParams {
+    first: number;
+    after?: string;
+    before?: string;
+    organizationId: string;
+    projectName: string;
+    branchName: string;
+}
+export interface TablesParams {
+    first: number;
+    after?: string;
+    revisionId: string;
+}
+export interface RowsParams {
+    first: number;
+    after?: string;
+    revisionId: string;
+    tableId: string;
+}
+export interface TableReferencesByParams {
+    first: number;
+    after?: string;
+    revisionId: string;
+    tableId: string;
+}
+export interface TableReferencesToParams {
+    first: number;
+    after?: string;
+    revisionId: string;
+    tableId: string;
+}
+export interface RowReferencesByParams {
+    referenceByTableId: string;
+    first: number;
+    after?: string;
+    revisionId: string;
+    tableId: string;
+    rowId: string;
+}
+export interface RowReferencesToParams {
+    referenceToTableId: string;
+    first: number;
+    after?: string;
+    revisionId: string;
+    tableId: string;
+    rowId: string;
+}
+export type QueryParamsType = Record<string | number, any>;
+export type ResponseFormat = keyof Omit<Body, 'body' | 'bodyUsed'>;
+export interface FullRequestParams extends Omit<RequestInit, 'body'> {
+    secure?: boolean;
+    path: string;
+    type?: ContentType;
+    query?: QueryParamsType;
+    format?: ResponseFormat;
+    body?: unknown;
+    baseUrl?: string;
+    cancelToken?: CancelToken;
+}
+export type RequestParams = Omit<FullRequestParams, 'body' | 'method' | 'query' | 'path'>;
+export interface ApiConfig<SecurityDataType = unknown> {
+    baseUrl?: string;
+    baseApiParams?: Omit<RequestParams, 'baseUrl' | 'cancelToken' | 'signal'>;
+    securityWorker?: (securityData: SecurityDataType | null) => Promise<RequestParams | void> | RequestParams | void;
+    customFetch?: typeof fetch;
+}
+export interface HttpResponse<D extends unknown, E extends unknown = unknown> extends Response {
+    data: D;
+    error: E;
+}
+type CancelToken = Symbol | string | number;
+export declare enum ContentType {
+    Json = "application/json",
+    FormData = "multipart/form-data",
+    UrlEncoded = "application/x-www-form-urlencoded",
+    Text = "text/plain"
+}
+export declare class HttpClient<SecurityDataType = unknown> {
+    baseUrl: string;
+    private securityData;
+    private securityWorker?;
+    private abortControllers;
+    private customFetch;
+    private baseApiParams;
+    constructor(apiConfig?: ApiConfig<SecurityDataType>);
+    setSecurityData: (data: SecurityDataType | null) => void;
+    protected encodeQueryParam(key: string, value: any): string;
+    protected addQueryParam(query: QueryParamsType, key: string): string;
+    protected addArrayQueryParam(query: QueryParamsType, key: string): any;
+    protected toQueryString(rawQuery?: QueryParamsType): string;
+    protected addQueryParams(rawQuery?: QueryParamsType): string;
+    private contentFormatters;
+    protected mergeRequestParams(params1: RequestParams, params2?: RequestParams): RequestParams;
+    protected createAbortSignal: (cancelToken: CancelToken) => AbortSignal | undefined;
+    abortRequest: (cancelToken: CancelToken) => void;
+    request: <T = any, E = any>({ body, secure, path, type, query, format, baseUrl, cancelToken, ...params }: FullRequestParams) => Promise<T>;
+}
+export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
+    login: (data: LoginDto, params?: RequestParams) => Promise<LoginResponse>;
+    createUser: (data: CreateUserDto, params?: RequestParams) => Promise<boolean>;
+    projects: ({ organizationId, ...query }: ProjectsParams, params?: RequestParams) => Promise<ProjectsConnection>;
+    createProject: ({ organizationId, ...query }: CreateProjectParams, data: CreateProjectDto, params?: RequestParams) => Promise<ProjectModel>;
+    usersOrganization: ({ organizationId, ...query }: UsersOrganizationParams, params?: RequestParams) => Promise<UsersOrganizationConnection>;
+    addUserToOrganization: (organizationId: string, data: AddUserToOrganizationDto, params?: RequestParams) => Promise<boolean>;
+    removeUserFromOrganization: (organizationId: string, data: RemoveUserFromOrganizationDto, params?: RequestParams) => Promise<boolean>;
+    project: (organizationId: string, projectName: string, params?: RequestParams) => Promise<ProjectModel>;
+    deleteProject: (organizationId: string, projectName: string, params?: RequestParams) => Promise<boolean>;
+    rootBranch: (organizationId: string, projectName: string, params?: RequestParams) => Promise<BranchModel>;
+    branches: ({ organizationId, projectName, ...query }: BranchesParams, params?: RequestParams) => Promise<BranchesConnection>;
+    usersProject: ({ organizationId, projectName, ...query }: UsersProjectParams, params?: RequestParams) => Promise<UsersProjectConnection>;
+    addUserToProject: (organizationId: string, projectName: string, data: AddUserToProjectDto, params?: RequestParams) => Promise<boolean>;
+    removeUserFromProject: (organizationId: string, projectName: string, userId: string, params?: RequestParams) => Promise<boolean>;
+    branch: (organizationId: string, projectName: string, branchName: string, params?: RequestParams) => Promise<BranchModel>;
+    branchTouched: (organizationId: string, projectName: string, branchName: string, params?: RequestParams) => Promise<boolean>;
+    parentBranch: (organizationId: string, projectName: string, branchName: string, params?: RequestParams) => Promise<ParentBranchResponse>;
+    startRevision: (organizationId: string, projectName: string, branchName: string, params?: RequestParams) => Promise<RevisionModel>;
+    headRevision: (organizationId: string, projectName: string, branchName: string, params?: RequestParams) => Promise<RevisionModel>;
+    draftRevision: (organizationId: string, projectName: string, branchName: string, params?: RequestParams) => Promise<RevisionModel>;
+    revisions: ({ organizationId, projectName, branchName, ...query }: RevisionsParams, params?: RequestParams) => Promise<RevisionsConnection>;
+    createRevision: (organizationId: string, projectName: string, branchName: string, data: CreateRevisionDto, params?: RequestParams) => Promise<RevisionModel>;
+    revertChanges: (organizationId: string, projectName: string, branchName: string, params?: RequestParams) => Promise<BranchModel>;
+    revision: (revisionId: string, params?: RequestParams) => Promise<RevisionModel>;
+    parentRevision: (revisionId: string, params?: RequestParams) => Promise<RevisionModel>;
+    childRevision: (revisionId: string, params?: RequestParams) => Promise<RevisionModel>;
+    childBranches: (revisionId: string, params?: RequestParams) => Promise<ChildBranchResponse[]>;
+    createBranch: (revisionId: string, data: CreateBranchByRevisionDto, params?: RequestParams) => Promise<BranchModel>;
+    tables: ({ revisionId, ...query }: TablesParams, params?: RequestParams) => Promise<TablesConnection>;
+    createTable: (revisionId: string, data: CreateTableDto, params?: RequestParams) => Promise<CreateTableResponse>;
+    endpoints: (revisionId: string, params?: RequestParams) => Promise<EndpointModel[]>;
+    createEndpoint: (revisionId: string, data: CreateEndpointDto, params?: RequestParams) => Promise<EndpointModel>;
+    table: (revisionId: string, tableId: string, params?: RequestParams) => Promise<TableModel>;
+    deleteTable: (revisionId: string, tableId: string, params?: RequestParams) => Promise<BranchModel>;
+    updateTable: (revisionId: string, tableId: string, data: UpdateTableDto, params?: RequestParams) => Promise<UpdateTableResponse>;
+    tableCountRows: (revisionId: string, tableId: string, params?: RequestParams) => Promise<number>;
+    rows: ({ revisionId, tableId, ...query }: RowsParams, params?: RequestParams) => Promise<RowsConnection>;
+    createRow: (revisionId: string, tableId: string, data: CreateRowDto, params?: RequestParams) => Promise<CreateRowResponse>;
+    tableSchema: (revisionId: string, tableId: string, params?: RequestParams) => Promise<object>;
+    tableCountReferencesBy: (revisionId: string, tableId: string, params?: RequestParams) => Promise<number>;
+    tableReferencesBy: ({ revisionId, tableId, ...query }: TableReferencesByParams, params?: RequestParams) => Promise<TablesConnection>;
+    tableCountReferencesTo: (revisionId: string, tableId: string, params?: RequestParams) => Promise<number>;
+    tableReferencesTo: ({ revisionId, tableId, ...query }: TableReferencesToParams, params?: RequestParams) => Promise<TablesConnection>;
+    row: (revisionId: string, tableId: string, rowId: string, params?: RequestParams) => Promise<RowModel>;
+    deleteRow: (revisionId: string, tableId: string, rowId: string, params?: RequestParams) => Promise<RemoveRowResponse>;
+    updateRow: (revisionId: string, tableId: string, rowId: string, data: UpdateRowDto, params?: RequestParams) => Promise<UpdateRowResponse>;
+    rowCountReferencesBy: (revisionId: string, tableId: string, rowId: string, params?: RequestParams) => Promise<number>;
+    rowReferencesBy: ({ revisionId, tableId, rowId, ...query }: RowReferencesByParams, params?: RequestParams) => Promise<RowsConnection>;
+    rowCountReferencesTo: (revisionId: string, tableId: string, rowId: string, params?: RequestParams) => Promise<number>;
+    rowReferencesTo: ({ revisionId, tableId, rowId, ...query }: RowReferencesToParams, params?: RequestParams) => Promise<RowsConnection>;
+    deleteEndpoint: (endpointId: string, params?: RequestParams) => Promise<boolean>;
+    health: {
+        healthControllerGet: (params?: RequestParams) => Promise<void>;
+    };
+}
+export {};