@difizen/libro-kernel 0.0.2-alpha.0

package/src/session/libro-session-protocol.ts

@@ -0,0 +1,61 @@
+import type { IKernelModel } from '../kernel/libro-kernel-protocol.js';
+import type { LibroKernel } from '../kernel/libro-kernel.js';
+
+import type { LibroSession } from './libro-session.js';
+
+export interface NotebookInSession {
+  name: string;
+  path: string;
+}
+
+export interface SessionMeta {
+  id: SessionId;
+  name: string;
+
+  type: string;
+
+  path: string;
+
+  kernel: LibroKernel;
+
+  notebook: NotebookInSession;
+}
+
+export const SessionMetaOption = Symbol('SessionMetaOption');
+
+export const SessionId = Symbol('LibroSessionId');
+export type SessionId = string;
+
+export const LibroSessionFactory = Symbol('LibroSessionFactory');
+export type LibroSessionFactory = (session: SessionMeta) => LibroSession;
+
+/**
+ * The session model returned by the server.
+ *
+ * #### Notes
+ * See the [Jupyter Notebook API](http://petstore.swagger.io/?url=https://raw.githubusercontent.com/jupyter/notebook/master/notebook/services/api/api.yaml#!/sessions).
+ */
+export interface SessionIModel {
+  /**
+   * The unique identifier for the session client.
+   */
+  readonly id: string;
+  readonly name: string;
+  readonly path: string;
+  readonly type: string;
+  readonly kernel: IKernelModel | null;
+}
+
+/**
+ * A session request.
+ *
+ * #### Notes
+ * The `path` and `type` session model parameters are required. The `name`
+ * parameter is not technically required, but is often assumed to be nonempty,
+ * so we require it too.
+ *
+ * See the [Jupyter Notebook API](http://petstore.swagger.io/?url=https://raw.githubusercontent.com/jupyter/notebook/master/notebook/services/api/api.yaml#!/sessions).
+ */
+export type ISessionOptions = Pick<SessionIModel, 'path' | 'type' | 'name'> & {
+  kernel?: Partial<Pick<IKernelModel, 'name'>>;
+};

package/src/session/libro-session.ts

@@ -0,0 +1,33 @@
+import { transient, inject } from '@difizen/mana-app';
+
+import type { LibroKernel } from '../kernel/libro-kernel.js';
+
+import type {
+  NotebookInSession,
+  SessionId,
+  SessionMeta,
+} from './libro-session-protocol.js';
+import { SessionMetaOption } from './libro-session-protocol.js';
+
+@transient()
+export class LibroSession {
+  id: SessionId;
+  name: string;
+
+  type: string;
+
+  path: string;
+
+  kernel: LibroKernel;
+
+  notebook: NotebookInSession;
+
+  constructor(@inject(SessionMetaOption) meta: SessionMeta) {
+    this.id = meta.id;
+    this.name = meta.name;
+    this.type = meta.type;
+    this.path = meta.path;
+    this.kernel = meta.kernel;
+    this.notebook = meta.notebook;
+  }
+}

package/src/session/restapi.ts

@@ -0,0 +1,126 @@
+// import { default as axios } from 'axios';
+import { URL } from '@difizen/libro-common';
+import { inject, singleton } from '@difizen/mana-app';
+
+import type { ISettings } from '../server/index.js';
+import { createResponseError } from '../server/index.js';
+import { ServerConnection } from '../server/server-connection.js';
+
+import type {
+  ISessionOptions,
+  SessionIModel,
+  SessionMeta,
+} from './libro-session-protocol.js';
+import { updateLegacySessionModel, validateModel } from './validate.js';
+
+export const SESSION_SERVICE_URL = 'api/sessions';
+
+export type DeepPartial<T> = {
+  [P in keyof T]?: DeepPartial<T[P]>;
+};
+
+/**
+ * Get a session url.
+ */
+export function getSessionUrl(baseUrl: string, id: string): string {
+  return URL.join(baseUrl, SESSION_SERVICE_URL, id);
+}
+
+@singleton()
+export class SessionRestAPI {
+  @inject(ServerConnection) serverConnection: ServerConnection;
+
+  // async startNewSession(params: {
+  //   fileName: string;
+  //   kernelName: string;
+  //   path: string;
+  //   type: string;
+  // }) {
+  //   try {
+  //     const res = await axios.post(`/api/sessions`, {
+  //       kernel: { name: params.kernelName }, // 来源于当前文件选择了哪一个kernel，名称来自于kernelspecs
+  //       name: params.fileName,
+  //       path: params.path,
+  //       type: params.type,
+  //     });
+  //     if (res.status === 201 && res.data) {
+  //       return res.data;
+  //     }
+  //   } catch (ex) {
+  //     return undefined;
+  //   }
+  // }
+
+  /**
+   * Create a new session, or return an existing session if the session path
+   * already exists.
+   */
+  async startSession(
+    options: ISessionOptions,
+    serverSettings?: Partial<ISettings>,
+  ): Promise<SessionIModel> {
+    const settings = { ...this.serverConnection.settings, ...serverSettings };
+    const url = URL.join(settings.baseUrl, SESSION_SERVICE_URL);
+    const init = {
+      method: 'POST',
+      body: JSON.stringify(options),
+    };
+    const response = await this.serverConnection.makeRequest(url, init, settings);
+
+    if (response.status !== 201) {
+      const err = await createResponseError(response);
+      throw err;
+    }
+    const data = await response.json();
+    updateLegacySessionModel(data);
+    validateModel(data);
+    return data;
+  }
+
+  /**
+   * List the running sessions.
+   */
+  async listRunning(serverSettings?: Partial<ISettings>): Promise<SessionMeta[]> {
+    const settings = { ...this.serverConnection.settings, ...serverSettings };
+    const url = URL.join(settings.baseUrl, SESSION_SERVICE_URL);
+    const response = await this.serverConnection.makeRequest(url, {}, settings);
+    if (response.status !== 200) {
+      const err = await createResponseError(response);
+      throw err;
+    }
+    const data = await response.json();
+
+    if (!Array.isArray(data)) {
+      throw new Error('Invalid Session list');
+    }
+    data.forEach((m) => {
+      updateLegacySessionModel(m);
+      validateModel(m);
+    });
+    return data;
+  }
+
+  /**
+   * Send a PATCH to the server, updating the session path or the kernel.
+   */
+  async updateSession(
+    model: Pick<SessionIModel, 'id'> & DeepPartial<Omit<SessionIModel, 'id'>>,
+    serverSettings?: Partial<ISettings>,
+  ): Promise<SessionIModel> {
+    const settings = { ...this.serverConnection.settings, ...serverSettings };
+    const url = getSessionUrl(settings.baseUrl, model.id);
+    const init = {
+      method: 'PATCH',
+      body: JSON.stringify(model),
+    };
+    const response = await this.serverConnection.makeRequest(url, init, settings);
+    if (response.status !== 200) {
+      const err = await createResponseError(response);
+      throw err;
+    }
+    const data = await response.json();
+    updateLegacySessionModel(data);
+    validateModel(data);
+    return data;
+  }
+}

package/src/session/session-module.ts

@@ -0,0 +1,26 @@
+import { ManaModule } from '@difizen/mana-app';
+
+import { LibroSessionManager } from './libro-session-manager.js';
+import type { SessionMeta } from './libro-session-protocol.js';
+import { LibroSessionFactory, SessionMetaOption } from './libro-session-protocol.js';
+import { LibroSession } from './libro-session.js';
+import { SessionRestAPI } from './restapi.js';
+
+export const LibroSessionModule = ManaModule.create().register(
+  SessionRestAPI,
+  LibroSession,
+  LibroSessionManager,
+  {
+    token: LibroSessionFactory,
+    useFactory: (ctx) => {
+      return (sessionMeta: SessionMeta) => {
+        const child = ctx.container.createChild();
+        child.register({
+          token: SessionMetaOption,
+          useValue: sessionMeta,
+        });
+        return child.get(LibroSession);
+      };
+    },
+  },
+);

package/src/session/validate.ts

@@ -0,0 +1,39 @@
+import { validateModel as validateKernelModel } from '../kernel/validate.js';
+import { validateProperty } from '../validate-property.js';
+
+import type { SessionMeta } from './libro-session-protocol.js';
+
+/**
+ * Validate an `Session.IModel` object.
+ */
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+export function validateModel(data: any): asserts data is SessionMeta {
+  validateProperty(data, 'id', 'string');
+  validateProperty(data, 'type', 'string');
+  validateProperty(data, 'name', 'string');
+  validateProperty(data, 'path', 'string');
+  validateProperty(data, 'kernel', 'object');
+  validateKernelModel(data.kernel);
+}
+
+/**
+ * Update model from legacy session data.
+ */
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+export function updateLegacySessionModel(data: any): void {
+  if (data.path === undefined && data.notebook !== undefined) {
+    data.path = data.notebook.path;
+    data.type = 'notebook';
+    data.name = '';
+  }
+}
+
+/**
+ * Validate an array of `Session.IModel` objects.
+ */
+export function validateModels(models: SessionMeta[]): asserts models is SessionMeta[] {
+  if (!Array.isArray(models)) {
+    throw new Error('Invalid session list');
+  }
+  models.forEach((d) => validateModel(d));
+}

package/src/utils.ts

@@ -0,0 +1,28 @@
+// 从localstorage获取值
+export const getPersist = (
+  key = '',
+  needParse = false,
+  defaultVal: string | undefined = undefined,
+) => {
+  const jsonStr = window.localStorage.getItem(key) || defaultVal;
+  if (!needParse) {
+    return jsonStr;
+  }
+  try {
+    if (!jsonStr) {
+      return defaultVal;
+    }
+    return JSON.parse(jsonStr);
+  } catch (ex) {
+    return defaultVal;
+  }
+};
+
+// 向localstorage更新值
+export const setPersist = (key = '', val = '') => {
+  window.localStorage.setItem(key, val);
+};
+
+export const removePersist = (key = '') => {
+  window.localStorage.removeItem(key);
+};

package/src/validate-property.ts

@@ -0,0 +1,38 @@
+export function validateProperty(
+  object: any,
+  name: string,
+  typeName?: string,
+  values: any[] = [],
+): void {
+  // eslint-disable-next-line no-prototype-builtins
+  if (!object.hasOwnProperty(name)) {
+    throw new Error(`Missing property '${name}`);
+  }
+  const value = object[name];
+  if (typeName !== void 0) {
+    let valid = true;
+    if (typeName === 'array') {
+      valid = Array.isArray(value);
+    } else if (typeName === 'object') {
+      valid = typeof value !== 'undefined';
+    } else {
+      valid = typeof value === typeName;
+    }
+    if (!valid) {
+      throw new Error(`Property '${name}' is not of type '${typeName}'`);
+    }
+    if (values.length > 0) {
+      let isValid = true;
+      if (['string', 'number', 'boolean'].includes(typeName)) {
+        isValid = values.includes(value);
+      } else {
+        isValid = values.findIndex((v) => v === value) >= 0;
+      }
+      if (!isValid) {
+        throw new Error(
+          `Property '${name}' is not one of the valid values ${JSON.stringify(values)}`,
+        );
+      }
+    }
+  }
+}