@eclipse-glsp/server 1.1.0-next.3d7585d.42

package/src/common/actions/client-action-handler.ts

@@ -0,0 +1,50 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { Action, ActionMessage } from '@eclipse-glsp/protocol';
+import { inject, injectable, optional } from 'inversify';
+import { ClientActionKinds, ClientId } from '../di/service-identifiers';
+import { GLSPClientProxy } from '../protocol/glsp-client-proxy';
+
+/**
+ * The client action handler is responsible of handling action kinds that are intended for the
+ * GLSP client, by sending them to the client over json-rpc.
+ */
+
+@injectable()
+export class ClientActionHandler implements ClientActionHandler {
+    @inject(GLSPClientProxy)
+    @optional()
+    protected glspClient?: GLSPClientProxy;
+
+    @inject(ClientId)
+    protected readonly clientId: string;
+
+    constructor(@inject(ClientActionKinds) @optional() public actionKinds: string[] = []) {}
+
+    execute(action: Action): [] {
+        this.send(action);
+        return [];
+    }
+
+    protected send(action: Action): void {
+        const message: ActionMessage = { action, clientId: this.clientId };
+        if (this.glspClient) {
+            this.glspClient.process(message);
+            return;
+        }
+        throw new Error('Could not send message to client. No GLSPClientProxy is defined');
+    }
+}

package/src/common/actions/global-action-provider.spec.ts

@@ -0,0 +1,79 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { Container, ContainerModule } from 'inversify';
+import { ClientActionKinds, DiagramModules, InjectionContainer } from '../di/service-identifiers';
+import { ClientSessionInitializer } from '../session/client-session-initializer';
+import * as mock from '../test/mock-util';
+import { Logger } from '../utils/logger';
+import { ActionHandler } from './action-handler';
+import { ActionHandlerRegistry } from './action-handler-registry';
+import { DefaultGlobalActionProvider } from './global-action-provider';
+import * as sinon from 'sinon';
+import { expect } from 'chai';
+
+describe('test DefaultGlobalActionProvider', () => {
+    const container = new Container();
+    const serverActions = ['A1', 'A2', 'A3'];
+    const clientActions = ['C1', 'C2'];
+    const diagramType = 'myDiagramType';
+
+    const handler1Actions = ['A1', 'A2'];
+    const handler2Actions = ['A2', 'A3'];
+
+    const h1 = new mock.StubActionHandler(handler1Actions);
+    const h2 = new mock.StubActionHandler(handler2Actions);
+
+    const handlerRegistry = new ActionHandlerRegistry();
+    sinon.stub(handlerRegistry, 'getAll').returns([h1, h2]);
+
+    const diagramModule1 = new ContainerModule(bind => {
+        bind(ClientSessionInitializer).toConstantValue(new mock.StubClientSessionInitializer());
+        bind(ActionHandler).toConstantValue(new mock.StubActionHandler(handler1Actions));
+        bind(ActionHandler).toConstantValue(new mock.StubActionHandler(handler2Actions));
+        bind(ActionHandlerRegistry).toConstantValue(handlerRegistry);
+        bind(ClientActionKinds).toConstantValue(clientActions[0]);
+        bind(ClientActionKinds).toConstantValue(clientActions[1]);
+    });
+
+    const diagramModules = new Map<string, ContainerModule[]>();
+    diagramModules.set(diagramType, [diagramModule1]);
+
+    container.load(
+        new ContainerModule(bind => {
+            bind(Logger).toConstantValue(new mock.StubLogger());
+            bind(InjectionContainer).toConstantValue(container);
+            bind(DiagramModules).toConstantValue(diagramModules);
+        })
+    );
+
+    const actionProvider = container.resolve(DefaultGlobalActionProvider);
+
+    it('serverActionsKinds', () => {
+        const result = actionProvider.serverActionKinds;
+        expect(result.size).to.be.equal(1);
+        const resultServerActions = result.get(diagramType);
+        expect(resultServerActions).to.not.be.undefined;
+        expect(serverActions.every(action => resultServerActions!.includes(action))).true;
+    });
+
+    it('clientActionKinds', () => {
+        const result = actionProvider.clientActionKinds;
+        expect(result.size).to.be.equal(1);
+        const resultClientActions = result.get(diagramType);
+        expect(resultClientActions).to.not.be.undefined;
+        expect(clientActions.every(action => resultClientActions!.includes(action))).true;
+    });
+});

package/src/common/actions/global-action-provider.ts

@@ -0,0 +1,72 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { Container, ContainerModule, inject, injectable } from 'inversify';
+import { ClientActionKinds, DiagramModules, InjectionContainer } from '../di/service-identifiers';
+import { ClientSessionInitializer } from '../session/client-session-initializer';
+import { ActionHandlerRegistry } from './action-handler-registry';
+import { ClientActionHandler } from './client-action-handler';
+
+export const GlobalActionProvider = Symbol('GlobalActionProvider');
+
+export interface GlobalActionProvider {
+    readonly serverActionKinds: Map<string, string[]>;
+    readonly clientActionKinds: Map<string, string[]>;
+}
+
+@injectable()
+export class DefaultGlobalActionProvider implements GlobalActionProvider {
+    public readonly serverActionKinds: Map<string, string[]>;
+    public readonly clientActionKinds: Map<string, string[]>;
+
+    constructor(
+        @inject(InjectionContainer) serverContainer: Container,
+        @inject(DiagramModules) diagramModules: Map<string, ContainerModule[]>
+    ) {
+        this.serverActionKinds = new Map();
+        this.clientActionKinds = new Map();
+        diagramModules.forEach((modules, diagramType) => {
+            const container = this.createDiagramContainer(serverContainer, modules);
+            const initializers = container.getAll<ClientSessionInitializer>(ClientSessionInitializer);
+            initializers.forEach(service => service.initialize());
+            this.loadServerActionKinds(diagramType, container);
+            this.loadClientActionKinds(diagramType, container);
+            container.unbindAll();
+        });
+    }
+
+    createDiagramContainer(serverContainer: Container, modules: ContainerModule[]): Container {
+        const container = serverContainer.createChild();
+        container.load(...modules);
+        return container;
+    }
+
+    loadServerActionKinds(diagramType: string, diagramContainer: Container): void {
+        const handlerRegistry = diagramContainer.get<ActionHandlerRegistry>(ActionHandlerRegistry);
+        const diagramServerActions = this.serverActionKinds.get(diagramType) ?? [];
+        handlerRegistry
+            .getAll()
+            .filter(handler => !(handler instanceof ClientActionHandler))
+            .forEach(handler => diagramServerActions.push(...handler.actionKinds));
+        this.serverActionKinds.set(diagramType, [...new Set(diagramServerActions)]);
+    }
+
+    loadClientActionKinds(diagramType: string, diagramContainer: Container): void {
+        const clientActionKinds = diagramContainer.getAll<string>(ClientActionKinds);
+        const diagramClientActions = this.clientActionKinds.get(diagramType) ?? [];
+        diagramClientActions.push(...clientActionKinds);
+        this.clientActionKinds.set(diagramType, diagramClientActions);
+    }
+}

package/src/common/command/command-stack.ts

@@ -0,0 +1,74 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { injectable } from 'inversify';
+import { Command } from './command';
+
+export const CommandStack = Symbol('CommandStack');
+
+/**
+ * A basic implementation of an undoable stack of commands.
+ * See {@link Command} for more details about the command methods that this implementation uses.
+ */
+export interface CommandStack {
+    /**
+     * Clears any redoable commands not yet redone, adds the command, and then executes the command.
+     * @param command the command to execute.
+     */
+    execute(command: Command): void;
+
+    /**
+     * Moves the top of the stack down, undoing what was formerly the top command.
+     */
+    undo(): void;
+
+    /**
+     * Moves the top of the stack up, redoing the new top command.
+     */
+    redo(): void;
+
+    /**
+     * The command stack has currently unsaved changes.
+     */
+    isDirty(): boolean;
+
+    /**
+     * Called after a save has been successfully performed.
+     */
+    saveIsDone(): void;
+}
+
+@injectable()
+export class DefaultCommandStack implements CommandStack {
+    execute(command: Command): void {
+        // no-op
+    }
+
+    undo(): void {
+        // no-op
+    }
+
+    redo(): void {
+        // no-op
+    }
+
+    isDirty(): boolean {
+        return false;
+    }
+
+    saveIsDone(): void {
+        // no-op
+    }
+}

package/src/common/command/command.ts

@@ -0,0 +1,39 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+/**
+ * An interface that every command is expected to support.
+ * A command can be executed, it can be undone, and can then be redone.
+ */
+export interface Command {
+    /**
+     * Performs the command activity required for the effect.
+     */
+    execute(): void;
+
+    /**
+     * Performs the command activity required to `undo` the effects of a preceding `execute` (or `redo`).
+     * The effect, if any, of calling `undo` before `execute` or `redo` have been called, is undefined.
+     */
+    undo(): void;
+
+    /**
+     * Performs the command activity required to `redo` the effect after undoing the effect.
+     * The effect, if any, of calling `redo` before `undo` is called is undefined.
+     * Note that if you implement `redo` to call `execute` then any derived class will be restricted by that decision also.
+     */
+    redo(): void;
+}

package/src/common/di/binding-target.spec.ts

@@ -0,0 +1,147 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { expect } from 'chai';
+import { Container, ContainerModule, interfaces } from 'inversify';
+import * as sinon from 'sinon';
+import { applyBindingTarget } from './binding-target';
+// Simple no op classes to construct inversify binding syntaxes.
+class Target {}
+
+class SubTarget extends Target {}
+
+describe('BindingTarget', () => {
+    describe('bindTarget()', () => {
+        // Setup nested spies for the fluent inversify binding API
+        let context: {
+            bind: sinon.SinonStub<[serviceIdentifier: interfaces.ServiceIdentifier<any>], interfaces.BindingToSyntax<any>>;
+            isBound: sinon.SinonStub<[serviceIdentifier: interfaces.ServiceIdentifier<any>], boolean>;
+        };
+        let toSyntax: sinon.SinonStubbedInstance<interfaces.BindingToSyntax<any>>;
+        let whenOnSyntax: sinon.SinonStubbedInstance<interfaces.BindingWhenOnSyntax<any>>;
+
+        const setupStubs = (): {
+            context: {
+                bind: sinon.SinonStub<[serviceIdentifier: interfaces.ServiceIdentifier<any>], interfaces.BindingToSyntax<any>>;
+                isBound: sinon.SinonStub<[serviceIdentifier: interfaces.ServiceIdentifier<any>], boolean>;
+            };
+            toSyntax: sinon.SinonStubbedInstance<interfaces.BindingToSyntax<any>>;
+            inWhenOnSyntax: sinon.SinonStubbedInstance<interfaces.BindingInWhenOnSyntax<any>>;
+            whenOnSyntax: sinon.SinonStubbedInstance<interfaces.BindingWhenOnSyntax<any>>;
+        } => {
+            const container = new Container();
+            const bind = sinon.stub<[serviceIdentifier: interfaces.ServiceIdentifier<any>], interfaces.BindingToSyntax<any>>();
+            const isBound = sinon.stub<[serviceIdentifier: interfaces.ServiceIdentifier<any>], boolean>();
+
+            let toSyntax: sinon.SinonStubbedInstance<interfaces.BindingToSyntax<any>> = {} as any;
+            let inWhenOnSyntax: sinon.SinonStubbedInstance<interfaces.BindingInWhenOnSyntax<any>> = {} as any;
+            container.load(
+                new ContainerModule(_bind => {
+                    const toStub = _bind('StubMe');
+                    inWhenOnSyntax = sinon.stub(toStub.to(Target));
+                    whenOnSyntax = sinon.stub(toStub.toConstantValue(''));
+                    toSyntax = sinon.stub(toStub);
+
+                    bind.returns(toSyntax);
+                    toSyntax.to.returns(inWhenOnSyntax);
+                    toSyntax.toSelf.returns(inWhenOnSyntax);
+                    toSyntax.toDynamicValue.returns(inWhenOnSyntax);
+                    toSyntax.toService.returns();
+                })
+            );
+
+            return {
+                context: { bind, isBound },
+                toSyntax,
+                inWhenOnSyntax,
+                whenOnSyntax
+            };
+        };
+
+        beforeEach(() => {
+            const stubs = setupStubs();
+            context = stubs.context;
+            toSyntax = stubs.toSyntax;
+            whenOnSyntax = stubs.whenOnSyntax;
+        });
+
+        describe('Bind to constructor', () => {
+            it('Should bind the service identifier `to` the given target with no scope', () => {
+                applyBindingTarget(context, Target, SubTarget);
+                expect(toSyntax.to.calledOnceWith(SubTarget)).to.be.true;
+            });
+
+            it('Should bind the service identifier `toSelf` with no scope', () => {
+                applyBindingTarget(context, Target, Target);
+                expect(toSyntax.toSelf.calledOnce).to.be.true;
+            });
+        });
+
+        describe('Bind to service', () => {
+            it('Should bind the service identifier `service` using the given target service with no scope', () => {
+                context.isBound.returns(true);
+                applyBindingTarget(context, Target, { service: SubTarget });
+                expect(toSyntax.toService.calledOnceWith(SubTarget)).to.be.true;
+            });
+            it('Should throw an error because the given target service is not bound', () => {
+                context.isBound.returns(false);
+                expect(() => applyBindingTarget(context, Target, { service: SubTarget, autoBind: false })).to.throw();
+            });
+            it('Should bind the unbound target service to itself before applying the toService binding', () => {
+                context.isBound.returns(false);
+                applyBindingTarget(context, Target, { service: SubTarget });
+                expect(context.bind.calledWith(Target)).to.be.true;
+            });
+            it('The return syntax should be no op and invocation of a syntax function should throw an error', () => {
+                context.isBound.returns(true);
+                const syntax = applyBindingTarget(context, Target, { service: SubTarget });
+                expect(() => {
+                    syntax.inRequestScope();
+                }).to.throw(
+                    `${Target.toString()} has been bound to 'service'.` +
+                        "Using 'in','when' or 'on' bindings after" +
+                        "a 'toService' binding is not possible."
+                );
+            });
+        });
+
+        describe('Bind to constant value', () => {
+            it('Should bind the service identifier `toConstantValue` using the given target with no scope', () => {
+                const subTarget = new SubTarget();
+                applyBindingTarget(context, Target, { constantValue: subTarget });
+                expect(toSyntax.toConstantValue.calledOnceWith(subTarget)).to.be.true;
+            });
+            it("The return syntax's in functions should be no op and invocation should log a warning", () => {
+                const spy = sinon.spy(console, 'warn');
+                const subTarget = new SubTarget();
+                const syntax = applyBindingTarget(context, Target, { constantValue: subTarget });
+                syntax.inSingletonScope();
+                expect(
+                    spy.calledWith(
+                        `${Target.toString()} has been bound to 'constantValue'. Binding in Singleton scope has no effect.` +
+                            'Constant value bindings are effectively Singleton bindings.'
+                    )
+                ).to.be.true;
+            });
+        });
+
+        describe('Bind to dynamic value', () => {
+            it('Should bind the service identifier `toDynamicValue` using the given factory function with no scope', () => {
+                applyBindingTarget(context, Target, { dynamicValue: context => new SubTarget() });
+                expect(toSyntax.toDynamicValue.calledOnce);
+            });
+        });
+    });
+});

package/src/common/di/binding-target.ts

@@ -0,0 +1,188 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { AnyObject, Constructor } from '@eclipse-glsp/protocol';
+import { interfaces } from 'inversify';
+/**
+ * Collection of utility types and functions to enable flexible service binding with dedicated
+ * binding methods in the GLSP DI modules
+ */
+
+/**
+ * Binds the given service identifier to the given {@link BindingTarget}. If the service identifier is
+ * a {@link Constructor} and the target is the same constructor the service identifier will be bound to itself.
+ * @param bind The inversify bind function (typically provided from a GLSP DI module)
+ * @param serviceIdentifier The service identifier that should be bound.
+ * @param target The binding target.
+ * @returns The corresponding {@link interfaces.BindingInWhenOnSyntax}.
+ */
+export function applyBindingTarget<T>(
+    context: { bind: interfaces.Bind; isBound: interfaces.IsBound },
+    serviceIdentifier: interfaces.ServiceIdentifier<T>,
+    target: BindingTarget<T>
+): interfaces.BindingInWhenOnSyntax<T> {
+    if (isConstructor(target)) {
+        // If service identifier and target are the same constructor => self binding
+        return serviceIdentifier === target //
+            ? context.bind(serviceIdentifier).toSelf()
+            : context.bind(serviceIdentifier).to(target);
+    } else if (ServiceTarget.is(target)) {
+        if (!context.isBound(target.service)) {
+            const autoBind = target.autoBind === undefined || target.autoBind === true;
+            if (autoBind && isConstructor(target.service)) {
+                context.bind(target.service).toSelf().inSingletonScope();
+            } else {
+                throw new Error(`The target service ${target.service.toString()} is not bound!. Cannot apply target binding`);
+            }
+        }
+        context.bind(serviceIdentifier).toService(target.service);
+        return NoOPSyntax.serviceSyntax(serviceIdentifier, target);
+    } else if (ConstantValueTarget.is(target)) {
+        const whenOnSyntax = context.bind(serviceIdentifier).toConstantValue(target.constantValue);
+        return NoOPSyntax.constantValueSyntax(serviceIdentifier, whenOnSyntax);
+    } else {
+        return context.bind(serviceIdentifier).toDynamicValue(_context => target.dynamicValue(_context));
+    }
+}
+
+export function applyOptionalBindingTarget<T>(
+    context: { bind: interfaces.Bind; isBound: interfaces.IsBound },
+    serviceIdentifier: interfaces.ServiceIdentifier<T>,
+    target?: BindingTarget<T>
+): interfaces.BindingInWhenOnSyntax<T> | undefined {
+    if (target) {
+        return applyBindingTarget(context, serviceIdentifier, target);
+    }
+    return undefined;
+}
+
+/**
+ * The different types of binding targets that can be returned by a dedicated binding method.
+ */
+export type BindingTarget<T> = Constructor<T> | DynamicValueTarget<T> | ConstantValueTarget<T> | ServiceTarget<T>;
+
+/**
+ * Binding target for service identifiers that should be bound `toConstantValue`.
+ */
+export interface ConstantValueTarget<T> {
+    constantValue: T;
+}
+
+export namespace ConstantValueTarget {
+    export function is(object: any): object is ConstantValueTarget<unknown> {
+        return AnyObject.is(object) && 'constantValue' in object;
+    }
+}
+
+/**
+ * Binding target for service identifiers that should be bound `toService`.
+ */
+export interface ServiceTarget<T> {
+    service: interfaces.ServiceIdentifier<T>;
+    /**
+     * Boolean flag to configure how to handle unbound service identifiers.
+     * If `undefined` or `true` the {@link applyBindingTarget} function will attempt unbound constructor service identifiers
+     * to `self().inSingletonScope()`.
+     */
+    autoBind?: boolean;
+}
+
+export namespace ServiceTarget {
+    export function is(object: any): object is ServiceTarget<unknown> {
+        return AnyObject.is(object) && 'service' in object;
+    }
+}
+
+/**
+ * Binding target for service identifiers that should be bound `toDynamicValue`.
+ */
+export interface DynamicValueTarget<T> {
+    dynamicValue(context: interfaces.Context): T;
+}
+
+/**
+ * No-op binding syntax definitions for `constantValue` and `toService` bindings.
+ * Using this no-op syntaxes allows the {@link applyBindingTarget} function to return a {@link interfaces.BindingInWhenOnSyntax}
+ * independently of the actual {@link BindingTarget}.
+ */
+namespace NoOPSyntax {
+    export function constantValueSyntax(
+        serviceIdentifier: interfaces.ServiceIdentifier<any>,
+        syntax: interfaces.BindingWhenOnSyntax<any>
+    ): interfaces.BindingInWhenOnSyntax<any> {
+        const noOpReturn = (scope: string): interfaces.BindingWhenOnSyntax<any> => {
+            console.warn(
+                `${serviceIdentifier.toString()} has been bound to 'constantValue'. Binding in ${scope} scope has no effect.` +
+                    'Constant value bindings are effectively Singleton bindings.'
+            );
+            return syntax;
+        };
+        return {
+            ...syntax,
+            inSingletonScope: () => noOpReturn('Singleton'),
+            inRequestScope: () => noOpReturn('Request'),
+            inTransientScope: () => noOpReturn('Transient')
+        };
+    }
+
+    export function serviceSyntax(
+        serviceIdentifier: interfaces.ServiceIdentifier<any>,
+        target: BindingTarget<any>
+    ): interfaces.BindingInWhenOnSyntax<any> {
+        const noOpReturn = (): interfaces.BindingInWhenOnSyntax<any> => {
+            const errorMsg =
+                `${serviceIdentifier.toString()} has been bound to 'service'.` +
+                "Using 'in','when' or 'on' bindings after" +
+                "a 'toService' binding is not possible.";
+            const error = new Error(errorMsg);
+            error.name = 'NoOpInvocation';
+            throw error;
+        };
+        const syntax = {
+            onActivation: noOpReturn,
+            when: noOpReturn,
+            whenAnyAncestorIs: noOpReturn,
+            whenAnyAncestorMatches: noOpReturn,
+            whenAnyAncestorNamed: noOpReturn,
+            whenAnyAncestorTagged: noOpReturn,
+            whenInjectedInto: noOpReturn,
+            whenNoAncestorIs: noOpReturn,
+            whenNoAncestorMatches: noOpReturn,
+            whenNoAncestorNamed: noOpReturn,
+            whenNoAncestorTagged: noOpReturn,
+            whenParentNamed: noOpReturn,
+            whenParentTagged: noOpReturn,
+            whenTargetIsDefault: noOpReturn,
+            whenTargetNamed: noOpReturn,
+            whenTargetTagged: noOpReturn,
+            inRequestScope: noOpReturn,
+            inSingletonScope: () => {
+                if (ServiceTarget.is(target)) {
+                    // toService bindings are essentially singleTons.
+                    // We don't throw an error in this case.
+                    return syntax;
+                }
+                return noOpReturn();
+            },
+            inTransientScope: noOpReturn
+        };
+
+        return syntax;
+    }
+}
+
+export function isConstructor(object: any): object is Constructor<unknown> {
+    return typeof object === 'function' && !!object.prototype && !!(object.prototype as any).constructor;
+}