@opensumi/ide-core-common 3.3.4-next-1727344885.0 → 3.4.1

package/src/remote-service/data-store/select.ts

@@ -0,0 +1,40 @@
+import { isIterable } from '@opensumi/ide-utils';
+
+export type Query = Record<string, any>;
+export type Store<T> = Iterable<T> | Record<string, T> | Map<string, T>;
+
+function makeMatcher(query: Query) {
+  const statements = [] as string[];
+  Object.entries(query).forEach(([key, value]) => {
+    statements.push(`item[${JSON.stringify(key)}] === ${JSON.stringify(value)}`);
+  });
+
+  const matcher = `
+    return ${statements.join(' && ')};
+  `;
+
+  return new Function('item', matcher) as (item: Query) => boolean;
+}
+
+export function select<I, T extends Store<I>>(items: T, query: Query): I[] {
+  const matcher = makeMatcher(query);
+  const result = [] as I[];
+
+  let _iterable: Iterable<any> | undefined;
+
+  if (items instanceof Map) {
+    _iterable = items.values();
+  } else if (isIterable(items)) {
+    _iterable = items;
+  } else {
+    _iterable = Object.values(items);
+  }
+
+  for (const item of _iterable) {
+    if (matcher(item)) {
+      result.push(item);
+    }
+  }
+
+  return result;
+}

package/src/remote-service/data-store/store.ts

@@ -0,0 +1,89 @@
+import extend from 'lodash/extend';
+
+import { EventEmitter } from '@opensumi/events';
+
+import { select } from './select';
+
+export interface DataStore<Item> {
+  create(item: Item): Item;
+  find(query: Record<string, any>): Item[] | undefined;
+  size(query: Record<string, any>): number;
+  get(id: string, query?: Record<string, any>): Item | undefined;
+  update(id: string, item: Partial<Item>): void;
+  remove(id: string): void;
+}
+
+export interface DataStoreEvent<Item> extends Record<string, any> {
+  created: [item: Item];
+  updated: [oldItem: Item, newItem: Item];
+  removed: [item: Item];
+}
+
+export interface DataStoreOptions {
+  id?: string;
+}
+
+export class InMemoryDataStore<Item> extends EventEmitter<DataStoreEvent<Item>> implements DataStore<Item> {
+  private store = new Map<string, Item>();
+  private _uid = 0;
+  /**
+   * primary key
+   */
+  private id: string;
+
+  constructor(protected options?: DataStoreOptions) {
+    super();
+    this.id = options?.id || 'id';
+  }
+
+  create(item: Item): Item {
+    const id = item[this.id] || String(this._uid++);
+    const result = extend({}, item, { [this.id]: id }) as Item;
+
+    this.store.set(id, result);
+
+    this.emit('created', result);
+    return result;
+  }
+
+  find(query: Record<string, any>): Item[] | undefined {
+    return select(this.store, query);
+  }
+
+  size(query?: Record<string, any>): number {
+    if (!query) {
+      return this.store.size;
+    }
+
+    return this.find(query)?.length || 0;
+  }
+
+  get(id: string): Item | undefined {
+    return this.store.get(id);
+  }
+
+  has(id: string): boolean {
+    return this.store.has(id);
+  }
+
+  update(id: string, item: Partial<Item>): void {
+    const current = this.store.get(id);
+    if (!current) {
+      return;
+    }
+
+    const result = extend({}, current, item);
+    this.emit('updated', current, result);
+
+    this.store.set(id, result);
+  }
+
+  remove(id: string): void {
+    const item = this.store.get(id);
+    if (item) {
+      this.emit('removed', item);
+    }
+
+    this.store.delete(id);
+  }
+}

package/src/remote-service/index.ts

@@ -0,0 +1,55 @@
+import { ConstructorOf, Inject, Injector, Token, markInjectable, setParameters } from '@opensumi/di';
+
+import { RPCProtocol } from '../types/rpc';
+
+export * from './data-store';
+
+export const CLIENT_ID_TOKEN = Symbol('CLIENT_ID_TOKEN');
+
+const RemoteServiceInstantiateFlag = Symbol('Do_Not_Allow_Instantiate_RemoteService');
+
+const RemoteServiceDataSymbol = Symbol('RemoteServiceData');
+
+function storeRemoteServiceData(target: any, servicePath: string, protocol?: RPCProtocol<any>) {
+  Reflect.defineMetadata(RemoteServiceDataSymbol, { servicePath, protocol }, target);
+}
+
+export function getRemoteServiceData(target: any): { servicePath: string; protocol?: RPCProtocol<any> } | undefined {
+  return Reflect.getMetadata(RemoteServiceDataSymbol, target);
+}
+
+export function RemoteService(servicePath: string, protocol?: RPCProtocol<any>) {
+  return function <T extends new (...args: any[]) => any>(constructor: T) {
+    markInjectable(constructor);
+    setParameters(constructor, [Symbol]);
+    Inject(RemoteServiceInstantiateFlag)(constructor, '', 0);
+    storeRemoteServiceData(constructor, servicePath, protocol);
+  };
+}
+
+RemoteService.getName = function (service: Token | ConstructorOf<any>): string {
+  if (typeof service === 'function') {
+    return service.name;
+  }
+  return String(service);
+};
+
+export interface RemoteServiceInternal<Client = any> {
+  rpcClient: Client[];
+
+  setConnectionClientId?(clientId: string): void;
+}
+
+export function runInRemoteServiceContext(injector: Injector, fn: () => void): Injector {
+  injector.overrideProviders({
+    token: RemoteServiceInstantiateFlag,
+    useValue: RemoteServiceInstantiateFlag,
+    override: true,
+  });
+
+  fn();
+
+  injector.disposeOne(RemoteServiceInstantiateFlag);
+  injector.creatorMap.delete(RemoteServiceInstantiateFlag);
+  return injector;
+}