@cratis/arc 18.0.0

package/commands/for_Command/when_executing/with_route_parameters.ts

@@ -0,0 +1,58 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import sinon from 'sinon';
+import { CommandWithRouteParams } from '../CommandWithRouteParams';
+import { given } from '../../../given';
+
+describe("when executing with route parameters", given(class {
+    command: CommandWithRouteParams;
+    fetchStub: sinon.SinonStub;
+
+    constructor() {
+        this.command = new CommandWithRouteParams();
+        this.command.setOrigin('http://localhost');
+        this.command.setApiBasePath('/api');
+        this.command.id = '123';
+        this.command.name = 'Test Item';
+        this.fetchStub = sinon.stub(globalThis, 'fetch');
+    }
+}, context => {
+    const responseData = {
+        correlationId: '12345678-1234-1234-1234-123456789012',
+        isSuccess: true,
+        isAuthorized: true,
+        isValid: true,
+        hasExceptions: false,
+        validationResults: [],
+        exceptionMessages: [],
+        exceptionStackTrace: '',
+        response: {}
+    };
+
+    beforeEach(async () => {
+        context.fetchStub.resolves({
+            status: 200,
+            json: async () => responseData
+        });
+
+        await context.command.execute();
+    });
+
+    afterEach(() => {
+        context.fetchStub.restore();
+    });
+
+    it("should_replace_route_parameters_in_url", () => {
+        const call = context.fetchStub.getCall(0);
+        const url = call.args[0];
+        url.toString().should.contain('/api/items/123');
+    });
+
+    it("should_include_all_properties_in_body", () => {
+        const call = context.fetchStub.getCall(0);
+        const body = JSON.parse(call.args[1].body);
+        body.id.should.equal('123');
+        body.name.should.equal('Test Item');
+    });
+}));

package/commands/for_Command/when_executing/with_successful_response.ts

@@ -0,0 +1,51 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { a_command } from '../given/a_command';
+import { given } from '../../../given';
+import { CommandResult } from '../../CommandResult';
+
+describe("when executing with successful response", given(a_command, context => {
+    let result: CommandResult<object>;
+    const responseData = {
+        correlationId: '12345678-1234-1234-1234-123456789012',
+        isSuccess: true,
+        isAuthorized: true,
+        isValid: true,
+        hasExceptions: false,
+        validationResults: [],
+        exceptionMessages: [],
+        exceptionStackTrace: '',
+        response: { data: 'test' }
+    };
+
+    beforeEach(async () => {
+        context.fetchStub.resolves({
+            status: 200,
+            json: async () => responseData
+        });
+
+        result = await context.command.execute();
+    });
+
+    afterEach(() => {
+        context.fetchStub.restore();
+    });
+
+    it("should_call_fetch_with_correct_url", () => context.fetchStub.calledOnce.should.be.true);
+
+    it("should_call_fetch_with_post_method", () => {
+        const call = context.fetchStub.getCall(0);
+        call.args[1].method.should.equal('POST');
+    });
+
+    it("should_call_fetch_with_json_headers", () => {
+        const call = context.fetchStub.getCall(0);
+        call.args[1].headers['Content-Type'].should.equal('application/json');
+        call.args[1].headers['Accept'].should.equal('application/json');
+    });
+
+    it("should_return_command_result", () => (result !== null && result !== undefined).should.be.true);
+
+    it("should_set_initial_values_from_current_values", () => context.command.hasChanges.should.be.false);
+}));

package/commands/for_Command/when_property_changed_value_that_is_different_from_initial_value.ts

@@ -0,0 +1,16 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { SomeCommand } from './SomeCommand';
+
+describe('when property changed value that is different from initial value', () => {
+    const command = new SomeCommand();
+    command.setInitialValues({
+        someProperty: ''
+    });
+
+    command.someProperty = '42';
+    command.propertyChanged('someProperty');
+
+    it('should have changes', () => command.hasChanges.should.be.true);
+});

package/commands/for_Command/when_property_changed_value_that_is_same_as_initial_value.ts

@@ -0,0 +1,16 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { SomeCommand } from './SomeCommand';
+
+describe('when property changed value that is same as initial value', () => {
+    const command = new SomeCommand();
+    command.setInitialValues({
+        someProperty: ''
+    });
+
+    command.someProperty = '';
+    command.propertyChanged('someProperty');
+
+    it('should have no changes', () => command.hasChanges.should.be.false);
+});

package/commands/for_Command/when_property_changes_and_initial_value_is_undefined.ts

@@ -0,0 +1,12 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { SomeCommand } from './SomeCommand';
+
+describe('when property changes and initial value is undefined', () => {
+    const command = new SomeCommand();
+    command.someProperty = '42';
+    command.propertyChanged('someProperty');
+
+    it('should have changes', () => command.hasChanges.should.be.true);
+});

package/commands/for_Command/when_property_changes_and_there_is_a_callback.ts

@@ -0,0 +1,15 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import sinon from 'sinon';
+import { SomeCommand } from './SomeCommand';
+
+describe('when property changes and there is a callback', () => {
+    const command = new SomeCommand();
+    const callback = sinon.stub();
+    command.onPropertyChanged(callback, command);
+
+    command.propertyChanged('someProperty');
+
+    it('should call the callback', () => callback.calledWith('someProperty').should.be.true);
+});

package/commands/for_Command/when_property_has_changed_and_we_revert.ts

@@ -0,0 +1,15 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { SomeCommand } from './SomeCommand';
+
+describe('when property has changed and we revert', () => {
+    const command = new SomeCommand();
+    command.setInitialValues({
+        someProperty: ''
+    });
+    command.someProperty = '42';
+    command.revertChanges();
+
+    it('should not have any changes', () => command.hasChanges.should.be.false);
+});

package/commands/for_Command/when_setting_initial_values_after_property_changed.ts

@@ -0,0 +1,17 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { SomeCommand } from './SomeCommand';
+
+describe('when setting initial values after property changed', () => {
+    const command = new SomeCommand();
+    command.setInitialValues({
+        someProperty: ''
+    });
+    command.someProperty = '42';
+    command.propertyChanged('someProperty');
+
+    command.setInitialValuesFromCurrentValues();
+
+    it('should not have any changes', () => command.hasChanges.should.be.false);
+});

package/commands/for_Command/when_validating/and_fetch_throws_exception.ts

@@ -0,0 +1,24 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { a_command } from '../given/a_command';
+import { given } from '../../../given';
+import { CommandResult } from '../../CommandResult';
+
+describe("when validating and fetch throws exception", given(a_command, context => {
+    let result: CommandResult<object>;
+
+    beforeEach(async () => {
+        context.fetchStub.rejects(new Error('Network error'));
+
+        result = await context.command.validate();
+    });
+
+    afterEach(() => {
+        context.fetchStub.restore();
+    });
+
+    it("should_return_failed_result", () => result.isSuccess.should.be.false);
+    it("should_include_error_message", () => result.exceptionMessages[0].should.contain('Error during validation call'));
+    it("should_have_exception_messages", () => (result.exceptionMessages.length > 0).should.be.true);
+}));

package/commands/for_Command/when_validating/and_validation_endpoint_not_found.ts

@@ -0,0 +1,26 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { a_command } from '../given/a_command';
+import { given } from '../../../given';
+import { CommandResult } from '../../CommandResult';
+
+describe("when validating and validation endpoint not found", given(a_command, context => {
+    let result: CommandResult<object>;
+
+    beforeEach(async () => {
+        context.fetchStub.resolves({
+            status: 404,
+            json: async () => ({})
+        });
+
+        result = await context.command.validate();
+    });
+
+    afterEach(() => {
+        context.fetchStub.restore();
+    });
+
+    it("should_return_failed_result", () => result.isSuccess.should.be.false);
+    it("should_have_exception_messages", () => (result.exceptionMessages.length > 0).should.be.true);
+}));

package/commands/for_Command/when_validating/does_not_update_initial_values.ts

@@ -0,0 +1,39 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { a_command } from '../given/a_command';
+import { given } from '../../../given';
+
+describe("when validating does not update initial values", given(a_command, context => {
+    const responseData = {
+        correlationId: '12345678-1234-1234-1234-123456789012',
+        isSuccess: true,
+        isAuthorized: true,
+        isValid: true,
+        hasExceptions: false,
+        validationResults: [],
+        exceptionMessages: [],
+        exceptionStackTrace: '',
+        response: {}
+    };
+
+    beforeEach(async () => {
+        context.command.someProperty = 'initial value';
+        context.command.setInitialValues({ someProperty: 'initial value' });
+        context.command.someProperty = 'changed value';
+        context.command.propertyChanged('someProperty');
+
+        context.fetchStub.resolves({
+            status: 200,
+            json: async () => responseData
+        });
+
+        await context.command.validate();
+    });
+
+    afterEach(() => {
+        context.fetchStub.restore();
+    });
+
+    it("should_still_have_changes_after_validation", () => context.command.hasChanges.should.be.true);
+}));

package/commands/for_Command/when_validating/with_successful_response.ts

@@ -0,0 +1,47 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { a_command } from '../given/a_command';
+import { given } from '../../../given';
+import { CommandResult } from '../../CommandResult';
+
+describe("when validating with successful response", given(a_command, context => {
+    let result: CommandResult<object>;
+    const responseData = {
+        correlationId: '12345678-1234-1234-1234-123456789012',
+        isSuccess: true,
+        isAuthorized: true,
+        isValid: true,
+        hasExceptions: false,
+        validationResults: [],
+        exceptionMessages: [],
+        exceptionStackTrace: '',
+        response: {}
+    };
+
+    beforeEach(async () => {
+        context.fetchStub.resolves({
+            status: 200,
+            json: async () => responseData
+        });
+
+        result = await context.command.validate();
+    });
+
+    afterEach(() => {
+        context.fetchStub.restore();
+    });
+
+    it("should_call_fetch_with_validate_route", () => {
+        const call = context.fetchStub.getCall(0);
+        const url = call.args[0];
+        url.toString().should.contain('/validate');
+    });
+
+    it("should_call_fetch_with_post_method", () => {
+        const call = context.fetchStub.getCall(0);
+        call.args[1].method.should.equal('POST');
+    });
+
+    it("should_return_command_result", () => (result !== null && result !== undefined).should.be.true);
+}));

package/commands/for_Command/when_validating/with_validation_errors.ts

@@ -0,0 +1,45 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { a_command } from '../given/a_command';
+import { given } from '../../../given';
+import { CommandResult } from '../../CommandResult';
+
+describe("when validating with validation errors", given(a_command, context => {
+    let result: CommandResult<object>;
+    const responseData = {
+        correlationId: '12345678-1234-1234-1234-123456789012',
+        isSuccess: false,
+        isAuthorized: true,
+        isValid: false,
+        hasExceptions: false,
+        validationResults: [
+            {
+                severity: 1,
+                message: 'Field is required',
+                members: ['someProperty'],
+                state: {}
+            }
+        ],
+        exceptionMessages: [],
+        exceptionStackTrace: '',
+        response: {}
+    };
+
+    beforeEach(async () => {
+        context.fetchStub.resolves({
+            status: 200,
+            json: async () => responseData
+        });
+
+        result = await context.command.validate();
+    });
+
+    afterEach(() => {
+        context.fetchStub.restore();
+    });
+
+    it("should_return_invalid_result", () => result.isValid.should.be.false);
+    it("should_not_be_successful", () => result.isSuccess.should.be.false);
+    it("should_not_update_initial_values", () => context.command.hasChanges.should.be.false);
+}));

package/commands/for_CommandResult/when_chaining_callbacks/and_result_has_exceptions.ts

@@ -0,0 +1,54 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { CommandResult } from '../../CommandResult';
+
+describe('when chaining callbacks and result has exceptions', () => {
+    const result = new CommandResult({
+        correlationId: '0c0ee8c8-b5a6-4999-b030-6e6a0c931b91',
+        isSuccess: false,
+        isAuthorized: true,
+        isValid: true,
+        hasExceptions: true,
+        validationResults: [],
+        exceptionMessages: [
+            'Something went wrong',
+            'Something is not right'
+        ],
+        exceptionStackTrace: 'Some stack trace',
+        response: {}
+    }, Object, false);
+
+    let onSuccessCalled = false;
+    let onFailedCalled = false;
+    let receivedCommandResultOnFailed: CommandResult<object>;
+    let onUnauthorizedCalled = false;
+    let onValidationFailureCalled = false;
+    let onExceptionCalled = false;
+    let receivedMessages: string[] = [];
+    let receivedStackTrace: string = '';
+
+    result
+        .onSuccess(() => onSuccessCalled = true)
+        .onFailed((commandResult) => {
+            onFailedCalled = true;
+            receivedCommandResultOnFailed = commandResult;
+        })
+        .onUnauthorized(() => onUnauthorizedCalled = true)
+        .onValidationFailure(() => onValidationFailureCalled = true)
+        .onException((messages, stackTrace) => {
+            onExceptionCalled = true;
+            receivedMessages = messages;
+            receivedStackTrace = stackTrace;
+        });
+
+    it('should not call the on success callback', () => onSuccessCalled.should.be.false);
+    it('should forward the exception messages to the callback', () => receivedMessages.should.equal(result.exceptionMessages));
+    it('should forward the exception stack trace to the callback', () => receivedStackTrace.should.equal(result.exceptionStackTrace));
+    it('should call the on failed callback', () => onFailedCalled.should.be.true);
+    it('should forward the command result to the on failed callback', () => receivedCommandResultOnFailed.should.equal(result));
+    it('should not call the on unauthorized callback', () => onUnauthorizedCalled.should.be.false);
+    it('should not call the on validation failure callback', () => onValidationFailureCalled.should.be.false);
+    it('should call the on exception callback', () => onExceptionCalled.should.be.true);
+});
+

package/commands/for_CommandResult/when_chaining_callbacks/and_result_is_invalid.ts

@@ -0,0 +1,53 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { ValidationResult } from '../../../validation/ValidationResult';
+import { ValidationResultSeverity } from '../../../validation/ValidationResultSeverity';
+import { CommandResult } from '../../CommandResult';
+
+describe('when chaining callbacks and result is invalid', () => {
+    const result = new CommandResult({
+        correlationId: '0c0ee8c8-b5a6-4999-b030-6e6a0c931b91',
+        isSuccess: false,
+        isAuthorized: true,
+        isValid: false,
+        hasExceptions: false,
+        validationResults: [
+            new ValidationResult(ValidationResultSeverity.Error, 'Something went wrong', ['someProperty'], 'Something went wrong'),
+            new ValidationResult(ValidationResultSeverity.Warning, 'Something is not right', ['someOtherProperty'], 'Something is not right')
+        ],
+        exceptionMessages: [],
+        exceptionStackTrace: '',
+        response: {}
+    }, Object, false);
+
+    let onSuccessCalled = false;
+    let onFailedCalled = false;
+    let receivedCommandResultOnFailed: CommandResult<object>;
+    let onUnauthorizedCalled = false;
+    let onValidationFailureCalled = false;
+    let onExceptionCalled = false;
+    let receivedValidationResults: ValidationResult[] = [];
+
+    result
+        .onSuccess(() => onSuccessCalled = true)
+        .onFailed((commandResult) => {
+            onFailedCalled = true;
+            receivedCommandResultOnFailed = commandResult;
+        })
+        .onUnauthorized(() => onUnauthorizedCalled = true)
+        .onValidationFailure(validationResults => {
+            onValidationFailureCalled = true;
+            receivedValidationResults = validationResults;
+        })
+        .onException(() => onExceptionCalled = true);
+
+    it('should not call the on success callback', () => onSuccessCalled.should.be.false);
+    it('should forward the validation results to the callback', () => receivedValidationResults.should.equal(result.validationResults));
+    it('should call the on failed callback', () => onFailedCalled.should.be.true);
+    it('should forward the command result to the on failed callback', () => receivedCommandResultOnFailed.should.equal(result));
+    it('should not call the on unauthorized callback', () => onUnauthorizedCalled.should.be.false);
+    it('should not call the on validation failure callback', () => onValidationFailureCalled.should.be.true);
+    it('should not call the on exception callback', () => onExceptionCalled.should.be.false);
+});
+

package/commands/for_CommandResult/when_chaining_callbacks/and_result_is_successful.ts

@@ -0,0 +1,42 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { CommandResult } from '../../CommandResult';
+
+describe('when chaining callbacks and result is successful', () => {
+    const result = new CommandResult<string>({
+        correlationId: '0c0ee8c8-b5a6-4999-b030-6e6a0c931b91',
+        isSuccess: true,
+        isAuthorized: true,
+        isValid: true,
+        hasExceptions: false,
+        validationResults: [],
+        exceptionMessages: [],
+        exceptionStackTrace: '',
+        response: 'The ultimate response'
+    }, Object, false);
+
+    let onSuccessCalled = false;
+    let onFailedCalled = false;
+    let onUnauthorizedCalled = false;
+    let onValidationFailureCalled = false;
+    let onExceptionCalled = false;
+    let receivedResponse: string | null = null;
+
+    result
+        .onSuccess(response => {
+            onSuccessCalled = true;
+            receivedResponse = response as string;
+        })
+        .onFailed(() => onFailedCalled = true)
+        .onUnauthorized(() => onUnauthorizedCalled = true)
+        .onValidationFailure(() => onValidationFailureCalled = true)
+        .onException(() => onExceptionCalled = true);
+
+    it('should call the on success callback', () => onSuccessCalled.should.be.true);
+    it('should pass the response to the callback', () => receivedResponse!.should.equal(result.response));
+    it('should not call the on failed callback', () => onFailedCalled.should.be.false);
+    it('should not call the on unauthorized callback', () => onUnauthorizedCalled.should.be.false);
+    it('should not call the on validation failure callback', () => onValidationFailureCalled.should.be.false);
+    it('should not call the on exception callback', () => onExceptionCalled.should.be.false);
+});

package/commands/for_CommandResult/when_chaining_callbacks/and_result_is_unauthorized.ts

@@ -0,0 +1,43 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { CommandResult } from '../../CommandResult';
+
+describe('when chaining callbacks and result is unauthorized', () => {
+    const result = new CommandResult({
+        correlationId: '0c0ee8c8-b5a6-4999-b030-6e6a0c931b91',
+        isSuccess: false,
+        isAuthorized: false,
+        isValid: true,
+        hasExceptions: false,
+        validationResults: [],
+        exceptionMessages: [],
+        exceptionStackTrace: '',
+        response: {}
+    }, Object, false);
+
+    let onSuccessCalled = false;
+    let onFailedCalled = false;
+    let receivedCommandResultOnFailed: CommandResult<object>;
+    let onUnauthorizedCalled = false;
+    let onValidationFailureCalled = false;
+    let onExceptionCalled = false;
+
+    result
+        .onSuccess(() => onSuccessCalled = true)
+        .onFailed((commandResult) => {
+            onFailedCalled = true;
+            receivedCommandResultOnFailed = commandResult;
+        })
+        .onUnauthorized(() => onUnauthorizedCalled = true)
+        .onValidationFailure(() => onValidationFailureCalled = true)
+        .onException(() => onExceptionCalled = true);
+
+    it('should not the on success callback', () => onSuccessCalled.should.be.false);
+    it('should call the on failed callback', () => onFailedCalled.should.be.true);
+    it('should forward the command result to the on failed callback', () => receivedCommandResultOnFailed.should.equal(result));
+    it('should call the on unauthorized callback', () => onUnauthorizedCalled.should.be.true);
+    it('should not call the on validation failure callback', () => onValidationFailureCalled.should.be.false);
+    it('should not call the on exception callback', () => onExceptionCalled.should.be.false);
+});
+

package/commands/index.ts

@@ -0,0 +1,9 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export * from './ICommand';
+export * from './Command';
+export * from './ICommandResult';
+export * from './CommandResult';
+export * from './CommandResults';
+export * from './CommandValidator';

package/deepEqual.ts

@@ -0,0 +1,23 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export const deepEqual = (obj1, obj2) => {
+    if (obj1 === obj2) return true; // Same reference or primitive value
+
+    if (obj1 == null || obj2 == null || typeof obj1 !== "object" || typeof obj2 !== "object") {
+        return false; // Handle null, undefined, or different types
+    }
+
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+
+    if (keys1.length !== keys2.length) {
+        return false; // Different number of keys
+    }
+
+    for (const key of keys1) {
+        if (!keys2.includes(key) || !deepEqual(obj1[key], obj2[key])) return false;
+    }
+
+    return true; // All keys and values match
+};

package/dist/cjs/GetHttpHeaders.d.ts

@@ -0,0 +1,2 @@
+export type GetHttpHeaders = () => HeadersInit;
+//# sourceMappingURL=GetHttpHeaders.d.ts.map

package/dist/cjs/GetHttpHeaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GetHttpHeaders.d.ts","sourceRoot":"","sources":["../../GetHttpHeaders.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,cAAc,GAAG,MAAM,WAAW,CAAC"}

package/dist/cjs/Globals.d.ts

@@ -0,0 +1,7 @@
+export interface IGlobals {
+    microservice: string;
+    microserviceHttpHeader: string;
+    microserviceWSQueryArgument: string;
+}
+export declare const Globals: IGlobals;
+//# sourceMappingURL=Globals.d.ts.map

package/dist/cjs/Globals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Globals.d.ts","sourceRoot":"","sources":["../../Globals.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,QAAQ;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,2BAA2B,EAAE,MAAM,CAAC;CACvC;AAED,eAAO,MAAM,OAAO,EAAE,QAIrB,CAAC"}

package/dist/cjs/Globals.js

@@ -0,0 +1,10 @@
+'use strict';
+
+const Globals = {
+    microservice: '',
+    microserviceHttpHeader: 'x-cratis-microservice',
+    microserviceWSQueryArgument: 'x-cratis-microservice'
+};
+
+exports.Globals = Globals;
+//# sourceMappingURL=Globals.js.map

package/dist/cjs/Globals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Globals.js","sources":["../../Globals.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nexport interface IGlobals {\n    microservice: string;\n    microserviceHttpHeader: string;\n    microserviceWSQueryArgument: string;\n}\n\nexport const Globals: IGlobals = {\n    microservice: '',\n    microserviceHttpHeader: 'x-cratis-microservice',\n    microserviceWSQueryArgument: 'x-cratis-microservice'\n};"],"names":[],"mappings":";;AASO,MAAM,OAAO,GAAa;AAC7B,IAAA,YAAY,EAAE,EAAE;AAChB,IAAA,sBAAsB,EAAE,uBAAuB;AAC/C,IAAA,2BAA2B,EAAE;;;;;"}