@vtex/api 6.48.0 → 6.48.1-beta

package/lib/service/logger/index.js

@@ -1,7 +1,70 @@
 "use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
 Object.defineProperty(exports, "__esModule", { value: true });
-__export(require("./console"));
-__export(require("./logger"));
+const error_1 = require("../../utils/error");
+const log_1 = require("../../utils/log");
+const linked = !!process.env.VTEX_APP_LINK;
+const app = process.env.VTEX_APP_ID;
+const EMPTY_MESSAGE = 'Logger.log was called with null or undefined message';
+const appName = process.env.VTEX_APP_NAME;
+const vendor = process.env.VTEX_APP_VENDOR;
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["Debug"] = "debug";
+    LogLevel["Info"] = "info";
+    LogLevel["Warn"] = "warn";
+    LogLevel["Error"] = "error";
+})(LogLevel = exports.LogLevel || (exports.LogLevel = {}));
+class Logger {
+    constructor(ctx) {
+        this.executed = false;
+        this.debug = (message) => this.log(message, LogLevel.Debug);
+        this.info = (message) => this.log(message, LogLevel.Info);
+        this.warn = (warning) => this.log(warning, LogLevel.Warn);
+        this.error = (error) => this.log(error, LogLevel.Error);
+        this.log = (message, level) => {
+            const data = message ? error_1.cleanError(message) : EMPTY_MESSAGE;
+            log_1.cleanLog(data);
+            /* tslint:disable:object-literal-sort-keys */
+            const inflatedLog = {
+                __VTEX_IO_LOG: true,
+                level,
+                app,
+                account: this.account,
+                workspace: this.workspace,
+                production: this.production,
+                data,
+                operationId: this.operationId,
+                requestId: this.requestId,
+            };
+            if (this.isThirdPartyApp()) {
+                Object.assign(inflatedLog, {
+                    __SKIDDER_TOPIC_1: `skidder.vendor.${vendor}`,
+                    __SKIDDER_TOPIC_2: `skidder.app.${vendor}.${appName}`,
+                });
+            }
+            console.log(JSON.stringify(inflatedLog));
+            // Warn the developer how to retrieve the error in splunk
+            this.logSplunkQuery();
+        };
+        /**
+         * Logs splunk query so the developer can search for the errors in splunk.
+         * This function runs only once in the lifetime of the Logger class so we
+         * don't mess up with the developer's terminal
+         */
+        this.logSplunkQuery = () => {
+            if (!this.executed && linked) {
+                console.log(`Try this query at Splunk to retrieve error log: 'index=io_vtex_logs app="${app}" account=${this.account} workspace=${this.workspace} level=error OR level=warn'`);
+                this.executed = true;
+            }
+        };
+        this.account = ctx.account;
+        this.workspace = ctx.workspace;
+        this.requestId = ctx.requestId;
+        this.operationId = ctx.operationId;
+        this.production = ctx.production;
+    }
+    isThirdPartyApp() {
+        return 'vtex' !== vendor && 'gocommerce' !== vendor;
+    }
+}
+exports.Logger = Logger;

package/lib/service/method.d.ts

@@ -0,0 +1,9 @@
+import { IOClients } from '../clients/IOClients';
+import { RouteHandler, ServiceContext } from './typings';
+declare type HTTPMethods = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH' | 'DEFAULT';
+declare type MethodOptions<ClientsT extends IOClients = IOClients, StateT = void, CustomT = void> = Partial<Record<HTTPMethods, RouteHandler<ClientsT, StateT, CustomT> | Array<RouteHandler<ClientsT, StateT, CustomT>>>>;
+export declare function method<ClientsT extends IOClients = IOClients, StateT = void, CustomT = void>(options: MethodOptions<ClientsT, StateT, CustomT>): {
+    (ctx: ServiceContext<ClientsT, StateT, CustomT>, next: () => Promise<any>): Promise<void>;
+    skipTimer: boolean;
+};
+export {};

package/lib/service/{worker/runtime/typings.d.ts → typings.d.ts}

@@ -1,37 +1,29 @@
 /// <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 { Span, Tracer } from 'opentracing';
 import { ParsedUrlQuery } from 'querystring';
-import { ClientsImplementation, IOClients } from '../../../clients/IOClients';
-import { InstanceOptions } from '../../../HttpClient';
-import { IUserLandTracer } from '../../../tracing/UserLandTracer';
-import { BindingHeader } from '../../../utils/binding';
-import { IOMessage } from '../../../utils/message';
-import { TenantHeader } from '../../../utils/tenant';
-import { Logger } from '../../logger';
-import { MetricsLogger } from '../../logger/metricsLogger';
-import { MessagesLoaderV2 } from './graphql/schema/messagesLoaderV2';
-import { Recorder } from './utils/recorder';
+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 declare type Maybe<T> = T | null | undefined;
-export interface TracingContext {
-    tracer: Tracer;
-    currentSpan: Span | undefined;
-}
 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];
-    requestHandlerName?: string;
     serverTiming?: ServerTiming;
-    tracing?: TracingContext;
 }
 export interface EventContext<T extends IOClients, StateT = any> {
     clients: T;
@@ -51,43 +43,35 @@ declare type KnownKeys<T> = {
 } ? U : never;
 interface Loaders {
     messages?: DataLoader<IOMessage, string>;
-    messagesV2?: MessagesLoaderV2;
-    immutableMessagesV2?: MessagesLoaderV2;
+    messagesV2?: DataLoader<IOMessageV2, string>;
 }
-export declare type ServiceContext<ClientsT extends IOClients = IOClients, StateT extends RecorderState = RecorderState, CustomT extends ParamsContext = ParamsContext> = Pick<ParameterizedContext<StateT, Context<ClientsT>>, KnownKeys<ParameterizedContext<StateT, Context<ClientsT>>>> & CustomT & {
-    loaders?: Loaders;
+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 extends RecorderState = RecorderState, CustomT extends ParamsContext = ParamsContext> = Middleware<ServiceContext<ClientsT, StateT, CustomT>>;
+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 extends RecorderState = RecorderState, CustomT extends ParamsContext = ParamsContext> = GraphQLFieldResolver<any, ServiceContext<ClientsT, StateT, CustomT>, any> | GraphQLFieldConfig<any, ServiceContext<ClientsT, StateT, CustomT>, any>;
-export declare type Handler = RouteHandler<IOClients, RecorderState, ParamsContext>;
-export interface HttpRoute {
-    handler: RouteHandler;
-    path: string;
-}
-export interface RecorderState {
-    recorder: Recorder;
-    body: any;
-}
-export interface ParamsContext {
-    params: any;
-    metricsLogger: MetricsLogger;
-}
+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 interface GraphQLOptions<ClientsT extends IOClients = IOClients, StateT extends RecorderState = RecorderState, CustomT extends ParamsContext = ParamsContext> {
+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>;
-    schema?: string;
+    dataSources?: DataSourcesGenerator;
     schemaDirectives?: Record<string, typeof SchemaDirectiveVisitor>;
 }
-export interface ServiceConfig<ClientsT extends IOClients = IOClients, StateT extends RecorderState = RecorderState, CustomT extends ParamsContext = ParamsContext> {
+export interface ServiceConfig<ClientsT extends IOClients = IOClients, StateT = void, CustomT = void> {
     clients?: ClientsConfig<ClientsT>;
-    events?: Record<string, EventHandler<ClientsT, StateT> | Array<EventHandler<ClientsT, StateT>>>;
+    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;
@@ -108,7 +92,6 @@ export interface IOContext {
         declarer?: string;
         id: string;
         params: ParsedUrlQuery;
-        type: 'public' | 'private' | 'event';
     };
     userAgent: string;
     workspace: string;
@@ -121,53 +104,36 @@ export interface IOContext {
     logger: Logger;
     eventInfo?: EventBody;
     host?: string;
-    tenant?: TenantHeader;
-    binding?: BindingHeader;
+    tenant?: Tenant;
+    binding?: Binding;
     cancellation?: Cancellation;
-    settings?: any;
-    tracer: IUserLandTracer;
 }
 export interface EventBody {
     sender: string;
     subject: string;
     key: string;
 }
-export declare type RouteSettingsType = 'pure' | 'workspace' | 'userAndWorkspace';
 export interface ServiceRoute {
     path: string;
+    method?: string[];
     public?: boolean;
     smartcache?: boolean;
-    extensible?: boolean;
-    settingsType?: RouteSettingsType;
-    rateLimitPerReplica?: RateLimitOptions;
-}
-export interface ServiceEvent {
-    keys?: string[];
-    sender?: string;
-    subject?: string;
-    settingsType?: RouteSettingsType;
-    rateLimitPerReplica?: RateLimitOptions;
 }
-export interface RateLimitOptions {
-    perMinute?: number;
-    concurrent?: number;
-}
-export interface RawServiceJSON {
+export interface ServiceDescriptor {
     stack: 'nodejs';
     memory: number;
     ttl?: number;
     timeout?: number;
     runtimeArgs?: string[];
     routes?: Record<string, ServiceRoute>;
-    rateLimitPerReplica?: RateLimitOptions;
-    events?: Record<string, ServiceEvent>;
-    minReplicas?: number;
-    maxReplicas?: number;
-    workers?: number;
+    events: {
+        [handler: string]: {
+            keys?: string[];
+            sender?: string;
+            subject?: string;
+        };
+    };
     deterministicVary?: boolean;
 }
-export interface ServiceJSON extends RawServiceJSON {
-    workers: number;
-}
 export declare type JanusEnv = string;
 export {};

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

@@ -0,0 +1,4 @@
+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/{worker/runtime/utils → utils}/compose.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (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");
+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.d.ts

@@ -1,8 +1,7 @@
-import { Logger } from './../service/logger/logger';
-import { ConflictsResolver, VBase } from '../clients/infra/VBase';
+import { ConflictsResolver, VBase } from '../clients/VBase';
 declare type Configuration = Record<string, ConfigurationData | ConfigurationData[] | object> | ConfigurationData[];
 declare type ConfigurationData = Record<string, object>;
-export declare class MineWinsConflictsResolver<T> implements ConflictsResolver<T> {
+export declare class MineWinsConflictsResolver implements ConflictsResolver {
     /***
      * Take mine and merge with master keys that have no conflict
      * We use base to decide wether a key was deleted or not
@@ -12,9 +11,8 @@ export declare class MineWinsConflictsResolver<T> implements ConflictsResolver<T
     private filePath;
     private comparableKeys;
     constructor(client: VBase, bucket: string, filePath: string, comparableKeys?: string[]);
-    resolve(logger?: Logger): Promise<any>;
-    resolveAll(): Promise<(Record<string, object | Record<string, object> | Record<string, object>[]> | Record<string, object>[])[]>;
-    protected mergeMineWins(base: Configuration, master: Configuration, mine: Configuration): Record<string, object | Record<string, object> | Record<string, object>[]> | Record<string, object>[];
+    resolve(): Promise<any>;
+    protected mergeMineWins(base: Configuration, master: Configuration, mine: Configuration): Configuration;
     private parseConflict;
     private serializeContentByMimetype;
     private parseContentByMimetype;

package/lib/utils/MineWinsConflictsResolver.js

@@ -10,15 +10,12 @@ class MineWinsConflictsResolver {
         this.filePath = filePath;
         this.comparableKeys = comparableKeys;
     }
-    async resolve(logger) {
-        return await this.client.getConflicts(this.bucket).then((data) => {
+    async resolve() {
+        return await this.client.getConflicts(this.bucket).then(data => {
             const { data: conflicts } = data;
-            const selectedConflict = conflicts.find((conflict) => conflict.path === this.filePath);
+            const selectedConflict = conflicts.find(conflict => conflict.path === this.filePath);
             if (!selectedConflict) {
-                throw {
-                    message: 'No conflict could be found.',
-                    status: 404,
-                };
+                return {};
             }
             selectedConflict.base.parsedContent = this.parseConflict(selectedConflict.base);
             selectedConflict.master.parsedContent = this.parseConflict(selectedConflict.master);
@@ -27,17 +24,6 @@ class MineWinsConflictsResolver {
             return resolved;
         });
     }
-    async resolveAll() {
-        const conflictsResponse = await this.client.getConflicts(this.bucket);
-        const { data: conflicts } = conflictsResponse;
-        const resolvedConflicts = conflicts.map((conflict) => {
-            conflict.base.parsedContent = this.parseConflict(conflict.base);
-            conflict.master.parsedContent = this.parseConflict(conflict.master);
-            conflict.mine.parsedContent = this.parseConflict(conflict.mine);
-            return this.resolveConflictMineWins(conflict);
-        });
-        return resolvedConflicts;
-    }
     mergeMineWins(base, master, mine) {
         if (util_1.isArray(master)) {
             return this.mergeMineWinsArray((base || []), master, (mine || []));
@@ -67,22 +53,19 @@ class MineWinsConflictsResolver {
     }
     resolveConflictMineWins(conflict) {
         if (!conflict) {
-            throw {
-                message: 'No conflict could be found.',
-                status: 404,
-            };
+            return {};
         }
         const { base, master, mine, path } = conflict;
-        const merged = this.mergeMineWins(base.parsedContent, master.parsedContent, mine.parsedContent);
+        this.mergeMineWins(base.parsedContent, master.parsedContent, mine.parsedContent);
         const mergedContent = {
-            content: js_base64_1.Base64.encode(this.serializeContentByMimetype(merged, conflict.mine.mimeType)),
+            content: js_base64_1.Base64.encode(this.serializeContentByMimetype(mine.parsedContent, conflict.mine.mimeType)),
             mimeType: conflict.mine.mimeType,
         };
         this.client.resolveConflict(this.bucket, path, mergedContent);
-        return merged;
+        return mine.parsedContent;
     }
     mergeMineWinsObject(base, master, mine) {
-        const merged = { ...master, ...mine };
+        const merged = Object.assign({}, master, mine);
         Object.entries(merged).forEach(([key, value]) => {
             if (master[key] == null && base && base[key] != null && ramda_1.equals(value, base[key])) {
                 delete merged[key]; // value deleted from master with no conflict
@@ -105,10 +88,10 @@ class MineWinsConflictsResolver {
         return mine;
     }
     removeMasterDeletedElements(base, master, mine) {
-        base.forEach((baseItem) => {
+        base.forEach(baseItem => {
             const foundInMaster = this.isObjectInArray(baseItem, master);
             if (!foundInMaster) {
-                const foundInMine = mine.findIndex((mineItem) => ramda_1.equals(mineItem, baseItem));
+                const foundInMine = mine.findIndex(mineItem => ramda_1.equals(mineItem, baseItem));
                 if (foundInMine > -1) {
                     mine.splice(foundInMine, 1);
                 }
@@ -116,21 +99,21 @@ class MineWinsConflictsResolver {
         });
     }
     isObjectInArray(obj, array) {
-        return array.find((item) => ramda_1.equals(item, obj));
+        return array.find(item => ramda_1.equals(item, obj));
     }
     appendMasterAddedElements(base, master, mine) {
-        master.forEach((item) => {
+        master.forEach(item => {
             if (this.shouldAddToMine(item, base, mine)) {
                 mine.push(item);
             }
         });
     }
     shouldAddToMine(item, base, mine) {
-        if (this.comparableKeys && Object.keys(item).some((key) => this.comparableKeys.includes(key))) {
-            return (!mine.some((mineItem) => this.comparableKeys.some((key) => ramda_1.eqProps(key, item, mineItem))) &&
-                !base.some((baseItem) => ramda_1.equals(baseItem, item)));
+        if (this.comparableKeys && Object.keys(item).some(key => this.comparableKeys.includes(key))) {
+            return (!mine.some(mineItem => this.comparableKeys.some(key => ramda_1.eqProps(key, item, mineItem))) &&
+                !base.some(baseItem => this.comparableKeys.some(key => ramda_1.eqProps(key, item, baseItem))));
         }
-        return !mine.some((mineItem) => ramda_1.equals(mineItem, item)) && !base.some((baseItem) => ramda_1.equals(baseItem, item));
+        return !mine.some(mineItem => ramda_1.equals(mineItem, item)) && !base.some(baseItem => ramda_1.equals(baseItem, item));
     }
 }
 exports.MineWinsConflictsResolver = MineWinsConflictsResolver;

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

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

package/lib/utils/MineWinsConflictsResolver.test.js

@@ -0,0 +1,134 @@
+"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/app.d.ts

@@ -1,4 +1,4 @@
-import { AppMetaInfo } from '../clients/infra/Apps';
+import { AppMetaInfo } from '../clients/Apps';
 export declare const removeBuild: (id: string) => string;
 export declare const removeVersionFromAppId: (appId: string) => string;
 export declare const extractVersionFromAppId: (appId: string) => string;
@@ -13,8 +13,6 @@ export declare const versionToMajorRange: (version: string) => string;
 export declare const formatMajorLocator: (name: string, version: string) => string;
 export declare const appIdToAppAtMajor: (appId: string) => string;
 export declare const isValidAppIdOrLocator: (appId: string) => boolean;
-export declare const sameMajor: (v1: string, v2: string) => boolean;
-export declare const majorEqualAndGreaterThan: (v1: string, v2: string) => boolean;
 export interface ParsedLocator {
     name: string;
     version: string;

package/lib/utils/app.js

@@ -23,7 +23,7 @@ exports.parseAppId = (appId) => {
         version: splittedVersion[0],
     };
 };
-exports.formatAppId = ({ locator, build }) => (build ? `${locator}+${build}` : locator);
+exports.formatAppId = ({ locator, build }) => build ? `${locator}+${build}` : locator;
 exports.satisfies = (appId, version) => {
     const { version: appVer } = exports.parseAppId(appId);
     return semver_1.default.satisfies(appVer, version);
@@ -44,5 +44,3 @@ const APP_ID_REGEX = /^[\w\-]+\.[\w\-]+@(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-
 exports.isValidAppIdOrLocator = (appId) => {
     return APP_ID_REGEX.test(appId);
 };
-exports.sameMajor = (v1, v2) => exports.versionToMajor(v1) === exports.versionToMajor(v2);
-exports.majorEqualAndGreaterThan = (v1, v2) => exports.sameMajor(v1, v2) && semver_1.default.gt(v1, v2);

package/lib/utils/appsStaleIfError.d.ts

@@ -2,7 +2,7 @@
 import { AppMetaInfo, Apps } from '..';
 import { CacheLayer } from '../caches';
 import { Logger } from '../service/logger';
-export declare const getMetaInfoKey: (account: string, workspace: string) => string;
+export declare const getMetaInfoKey: (account: string) => string;
 export declare const updateMetaInfoCache: (cacheStorage: CacheLayer<string, AppMetaInfo[]>, account: string, workspace: string, dependencies: AppMetaInfo[], logger: Logger) => Promise<void>;
 export declare const saveVersion: (app: string, cacheStorage: CacheLayer<string, string>) => Promise<void>;
 export declare const getFallbackFile: (app: string, path: string, cacheStorage: CacheLayer<string, string>, apps: Apps) => Promise<{

package/lib/utils/appsStaleIfError.js

@@ -13,7 +13,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const crypto_1 = __importDefault(require("crypto"));
 const ramda_1 = require("ramda");
 const semver = __importStar(require("semver"));
-exports.getMetaInfoKey = (account, workspace) => `${account}-${workspace}-meta-infos`;
+exports.getMetaInfoKey = (account) => `${account}-meta-infos`;
 const hashMD5 = (text) => crypto_1.default
     .createHash('md5')
     .update(text)
@@ -22,7 +22,7 @@ exports.updateMetaInfoCache = async (cacheStorage, account, workspace, dependenc
     if (workspace !== 'master') {
         return;
     }
-    const key = exports.getMetaInfoKey(account, workspace);
+    const key = exports.getMetaInfoKey(account);
     const hash = hashMD5(dependencies.toString());
     try {
         const storedDependencies = await cacheStorage.get(key) || '';

package/lib/utils/billingOptions.d.ts

@@ -1,36 +1,3 @@
-export declare const isFreeBillingOptions: (billingOptions: BillingOptions) => boolean;
-export interface BillingOptions {
-    type: BILLING_TYPE;
-    support: Support;
-    availableCountries: string[];
-    plans?: Plan[];
-}
-export declare enum BILLING_TYPE {
-    FREE = "free",
-    BILLABLE = "billable",
-    SPONSORED = "sponsored"
-}
-export interface PriceMetric {
-    id: string;
-    ranges: Range[];
-    customUrl: string;
-}
-export interface Range {
-    exclusiveFrom: number;
-    inclusiveTo?: number;
-    multiplier: number;
-}
-export interface Plan {
-    id: string;
-    currency: string;
-    price: Price;
-}
-export interface Price {
-    subscription?: number;
-    metrics?: PriceMetric[];
-}
-export interface Support {
-    email: string;
-    url?: string;
-    phone?: string;
-}
+import { BillingOptions, CalculationItem, FixedCalculationItem, FreeBillingOptions } from '../responses';
+export declare const isFreeBillingOptions: (billingOptions: BillingOptions) => billingOptions is FreeBillingOptions;
+export declare const isFixedCalculationItem: (item: CalculationItem) => item is FixedCalculationItem;