@vtex/api 6.48.1-beta → 6.48.1-beta.2

package/lib/service/typings.d.ts

@@ -1,139 +0,0 @@
-/// <reference types="node" />
-import { DataSource } from 'apollo-datasource';
-import { CancelTokenSource } from 'axios';
-import DataLoader from 'dataloader';
-import { GraphQLFieldConfig, GraphQLFieldResolver, GraphQLScalarType } from 'graphql';
-import { SchemaDirectiveVisitor } from 'graphql-tools';
-import { ParameterizedContext } from 'koa';
-import { Middleware } from 'koa-compose';
-import { ParsedUrlQuery } from 'querystring';
-import { ClientsImplementation, IOClients } from '../clients/IOClients';
-import { IOMessageV2 } from '../clients/MessagesGraphQL';
-import { InstanceOptions } from '../HttpClient';
-import { Recorder } from '../HttpClient/middlewares/recorder';
-import { Binding } from '../utils/binding';
-import { IOMessage } from '../utils/message';
-import { Tenant } from '../utils/tenant';
-import { Logger } from './logger';
-declare type ServerTiming = Record<string, string>;
-export interface Context<T extends IOClients> {
-    clients: T;
-    vtex: IOContext;
-    dataSources?: DataSources;
-    timings: Record<string, [number, number]>;
-    metrics: Record<string, [number, number]>;
-    previousTimerStart: [number, number];
-    serverTiming?: ServerTiming;
-}
-export interface EventContext<T extends IOClients, StateT = any> {
-    clients: T;
-    state: StateT;
-    vtex: IOContext;
-    body: any;
-    timings: Record<string, [number, number]>;
-    metrics: Record<string, [number, number]>;
-    key: string;
-    sender: string;
-    subject: string;
-}
-declare type KnownKeys<T> = {
-    [K in keyof T]: string extends K ? never : number extends K ? never : K;
-} extends {
-    [_ in keyof T]: infer U;
-} ? U : never;
-interface Loaders {
-    messages?: DataLoader<IOMessage, string>;
-    messagesV2?: DataLoader<IOMessageV2, string>;
-}
-export declare type ServiceContext<ClientsT extends IOClients = IOClients, StateT = void, CustomT = void> = Pick<ParameterizedContext<StateT, Context<ClientsT>>, KnownKeys<ParameterizedContext<StateT, Context<ClientsT>>>> & CustomT & {
-    loaders: Loaders;
-};
-export declare type RouteHandler<ClientsT extends IOClients = IOClients, StateT = void, CustomT = void> = Middleware<ServiceContext<ClientsT, StateT, CustomT>>;
-export declare type EventHandler<ClientsT extends IOClients = IOClients, StateT = void> = Middleware<EventContext<ClientsT, StateT>>;
-export declare type Resolver<ClientsT extends IOClients = IOClients, StateT = void, CustomT = void> = GraphQLFieldResolver<any, ServiceContext<ClientsT, StateT, CustomT>, any> | GraphQLFieldConfig<any, ServiceContext<ClientsT, StateT, CustomT>, any>;
-export interface ClientsConfig<ClientsT extends IOClients = IOClients> {
-    implementation?: ClientsImplementation<ClientsT>;
-    options: Record<string, InstanceOptions>;
-}
-export declare type DataSourcesGenerator = () => {
-    [name: string]: DataSource<ServiceContext>;
-};
-export interface GraphQLOptions<ClientsT extends IOClients = IOClients, StateT = void, CustomT = void> {
-    resolvers: Record<string, Record<string, Resolver<ClientsT, StateT, CustomT>> | GraphQLScalarType>;
-    dataSources?: DataSourcesGenerator;
-    schemaDirectives?: Record<string, typeof SchemaDirectiveVisitor>;
-}
-export interface ServiceConfig<ClientsT extends IOClients = IOClients, StateT = void, CustomT = void> {
-    clients?: ClientsConfig<ClientsT>;
-    events?: any;
-    graphql?: GraphQLOptions<ClientsT, StateT, CustomT>;
-    routes?: Record<string, RouteHandler<ClientsT, StateT, CustomT> | Array<RouteHandler<ClientsT, StateT, CustomT>>>;
-}
-export interface DataSources {
-    [name: string]: DataSource<ServiceContext>;
-}
-export interface Cancellation {
-    cancelable: boolean;
-    cancelled: boolean;
-    source: CancelTokenSource;
-}
-export interface IOContext {
-    account: string;
-    platform: string;
-    authToken: string;
-    adminUserAuthToken?: string;
-    storeUserAuthToken?: string;
-    locale?: string;
-    production: boolean;
-    product: string;
-    recorder?: Recorder;
-    region: string;
-    route: {
-        declarer?: string;
-        id: string;
-        params: ParsedUrlQuery;
-    };
-    userAgent: string;
-    workspace: string;
-    segmentToken?: string;
-    sessionToken?: string;
-    requestId: string;
-    operationId: string;
-    janusEnv?: JanusEnv;
-    serverTiming?: ServerTiming;
-    logger: Logger;
-    eventInfo?: EventBody;
-    host?: string;
-    tenant?: Tenant;
-    binding?: Binding;
-    cancellation?: Cancellation;
-}
-export interface EventBody {
-    sender: string;
-    subject: string;
-    key: string;
-}
-export interface ServiceRoute {
-    path: string;
-    method?: string[];
-    public?: boolean;
-    smartcache?: boolean;
-}
-export interface ServiceDescriptor {
-    stack: 'nodejs';
-    memory: number;
-    ttl?: number;
-    timeout?: number;
-    runtimeArgs?: string[];
-    routes?: Record<string, ServiceRoute>;
-    events: {
-        [handler: string]: {
-            keys?: string[];
-            sender?: string;
-            subject?: string;
-        };
-    };
-    deterministicVary?: boolean;
-}
-export declare type JanusEnv = string;
-export {};

package/lib/service/utils/compose.d.ts

@@ -1,4 +0,0 @@
-import koaCompose from 'koa-compose';
-import { IOClients } from '../../clients/IOClients';
-export declare const compose: <ClientsT extends IOClients, StateT, CustomT>(middlewares: koaCompose.Middleware<import("../typings").ServiceContext<ClientsT, StateT, CustomT>>[]) => koaCompose.ComposedMiddleware<import("../typings").ServiceContext<ClientsT, StateT, CustomT>>;
-export declare const composeForEvents: <ClientsT extends IOClients, StateT>(middlewares: any[]) => koaCompose.ComposedMiddleware<import("../typings").EventContext<IOClients, {}>>;

package/lib/service/utils/compose.js

@@ -1,11 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const koa_compose_1 = __importDefault(require("koa-compose"));
-const ramda_1 = require("ramda");
-const cancel_1 = require("../../utils/cancel");
-const time_1 = require("../../utils/time");
-exports.compose = (middlewares) => koa_compose_1.default(middlewares.map(ramda_1.pipe(time_1.timer, cancel_1.cancel)));
-exports.composeForEvents = (middlewares) => koa_compose_1.default(middlewares.map(time_1.timerForEvents));

package/lib/utils/MineWinsConflictsResolver.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/utils/MineWinsConflictsResolver.test.js

@@ -1,134 +0,0 @@
-"use strict";
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
-    result["default"] = mod;
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const TypeMoq = __importStar(require("typemoq"));
-const MineWinsConflictsResolver_1 = require("./MineWinsConflictsResolver");
-describe('MineWinsConflictsResolver', () => {
-    const VBaseMock = TypeMoq.Mock.ofType();
-    const resolver = new (class extends MineWinsConflictsResolver_1.MineWinsConflictsResolver {
-        constructor() {
-            super(VBaseMock.object, 'test', '/test', ['a']);
-        }
-        mergeMineWins(base, master, mine) {
-            return super.mergeMineWins(base, master, mine);
-        }
-    })();
-    it('Should merge object master and mine additions', async () => {
-        const master = { a: 1 };
-        const base = {};
-        const mine = { b: 2 };
-        const expected = { a: 1, b: 2 };
-        const result = resolver.mergeMineWins(base, master, mine);
-        expect(result).toEqual(expected);
-    });
-    it('Should keep mine object over master on keys conflict', async () => {
-        const master = { a: 0, b: 1 };
-        const base = {};
-        const mine = { b: 2, c: 3 };
-        const expected = { a: 0, b: 2, c: 3 };
-        const result = resolver.mergeMineWins(base, master, mine);
-        expect(result).toEqual(expected);
-    });
-    it('Should only add master object to mine if it wasn deleted', async () => {
-        const master = { b: 1 };
-        const base = { b: 1 };
-        const mine = {};
-        const expected = {};
-        const result = resolver.mergeMineWins(base, master, mine);
-        expect(result).toEqual(expected);
-    });
-    it('Should delete object from mine when it is deleted from master and there is no conflict', async () => {
-        const master = {};
-        const base = { a: 1 };
-        const mine = { a: 1, b: 2 };
-        const expected = { b: 2 };
-        const result = resolver.mergeMineWins(base, master, mine);
-        expect(result).toEqual(expected);
-    });
-    it('Should keep mine object when it is deleted from master and there is conflict', async () => {
-        const master = {};
-        const base = { a: 1 };
-        const mine = { a: 2 };
-        const expected = { a: 2 };
-        const result = resolver.mergeMineWins(base, master, mine);
-        expect(result).toEqual(expected);
-    });
-    it('Should append master array values to mine arrays when they dont already exist', async () => {
-        const master = [{ a: 1 }];
-        const base = [{}];
-        const mine = [{ b: 2 }];
-        const expected = [{ b: 2 }, { a: 1 }];
-        const result = resolver.mergeMineWins(base, master, mine);
-        expect(result).toEqual(expected);
-        const master1 = { a: [{ z: [{ stuff0: 0 }, { stuff1: 1 }] }] };
-        const base1 = { a: [{ z: [{ stuff0: 0 }] }] };
-        const mine1 = { a: [{ z: [{ stuff0: 0 }] }] };
-        const expected1 = { a: [{ z: [{ stuff0: 0 }, { stuff1: 1 }] }] };
-        const result1 = resolver.mergeMineWins(base1, master1, mine1);
-        expect(result1).toEqual(expected1);
-        const master2 = { b: [{ z: [{ stuff0: 0 }, { stuff1: 1 }] }] };
-        const base2 = { b: [{ z: [{ stuff0: 0 }] }] };
-        const mine2 = { b: [{ z: [{ stuff0: 0 }] }] };
-        const expected2 = { b: [{ z: [{ stuff0: 0 }, { stuff1: 1 }] }] };
-        const result2 = resolver.mergeMineWins(base2, master2, mine2);
-        expect(result2).toEqual(expected2);
-    });
-    it('Should not append master array values when they already exist in mine', async () => {
-        const master = [{ a: 1 }, { b: 2 }];
-        const base = [{}];
-        const mine = [{ b: 2 }];
-        const expected = [{ b: 2 }, { a: 1 }];
-        const result = resolver.mergeMineWins(base, master, mine);
-        expect(result).toEqual(expected);
-    });
-    it('Should keep mine array values in case of conflicts on comparableKeys', async () => {
-        const master = [{ a: 1, c: 3 }, { b: 2 }];
-        const base = [];
-        const mine = [{ a: 1 }];
-        const expected = [{ a: 1 }, { b: 2 }];
-        const result = resolver.mergeMineWins(base, master, mine);
-        expect(result).toEqual(expected);
-    });
-    it('Should delete from mine array values deleted from master with no conflict', async () => {
-        const master = [];
-        const base = [{ a: 1 }];
-        const mine = [{ a: 1 }, { b: 2 }];
-        const expected = [{ b: 2 }];
-        const result = resolver.mergeMineWins(base, master, mine);
-        expect(result).toEqual(expected);
-    });
-    it('Should only append array value to mine if it wasnt deleted from it', async () => {
-        const master = [{ b: 1 }];
-        const base = [{ b: 1 }];
-        const mine = [];
-        const expected = [];
-        const result = resolver.mergeMineWins(base, master, mine);
-        expect(result).toEqual(expected);
-    });
-    it('Should work with nullable inner objects', async () => {
-        const master = { a: [{ b: 1 }] };
-        const base = {};
-        const mine = {};
-        const expected = { a: [{ b: 1 }] };
-        const result = resolver.mergeMineWins(base, master, mine);
-        expect(result).toEqual(expected);
-        const master2 = { a: { b: 1 } };
-        const base2 = {};
-        const mine2 = {};
-        const expected2 = { a: { b: 1 } };
-        const result2 = resolver.mergeMineWins(base2, master2, mine2);
-        expect(result2).toEqual(expected2);
-        const master3 = { a: { b: 1 } };
-        const base3 = { a: {} };
-        const mine3 = {};
-        const expected3 = {};
-        const result3 = resolver.mergeMineWins(base3, master3, mine3);
-        expect(result3).toEqual(expected3);
-    });
-});

package/lib/utils/unhandled.d.ts

@@ -1 +0,0 @@
-export declare const addProcessListeners: () => void;