enhance(schema); relatime schema updates for server

Author: kevinslin

packages/api-server/src/modules/schemas/index.ts

@@ -4,6 +4,8 @@ import {
   SchemaDeleteRequest,
   SchemaQueryPayload,
   SchemaQueryRequest,
+  SchemaUpdatePayload,
+  SchemaUpdateRequest,
   SchemaWritePayload,
   SchemaWriteRequest,
 } from "@dendronhq/common-server";
@@ -66,4 +68,23 @@ export class SchemaController {
     }
     return await engine.querySchema(qs);
   }
+
+  async update({
+    ws,
+    schema,
+  }: SchemaUpdateRequest): Promise<SchemaUpdatePayload> {
+    const engine = await MemoryStore.instance().get<DEngineV2>(`ws:${ws}`);
+    if (!engine) {
+      throw "No Engine";
+    }
+    try {
+      await engine.updateSchema(schema);
+      return { error: null };
+    } catch (err) {
+      return {
+        error: new DendronError({ msg: JSON.stringify(err) }),
+        data: undefined,
+      };
+    }
+  }
 }

packages/api-server/src/routes/schema.ts

@@ -1,6 +1,7 @@
 import {
   SchemaDeleteRequest,
   SchemaQueryRequest,
+  SchemaUpdateRequest,
   SchemaWriteRequest,
 } from "@dendronhq/common-server";
 import { Request, Response, Router } from "express";
@@ -22,6 +23,13 @@ router.post("/query", async (req: Request, res: Response) => {
   res.json(resp);
 });
 
+router.post("/update", async (req: Request, res: Response) => {
+  const resp = await SchemaController.instance().update(
+    req.body as SchemaUpdateRequest
+  );
+  res.json(resp);
+});
+
 router.post("/write", async (req: Request, res: Response) => {
   const resp = await SchemaController.instance().create(
     req.body as SchemaWriteRequest

packages/common-server/src/filesv2.ts

@@ -1,5 +1,6 @@
 import {
   DNodeUtilsV2,
+  DVault,
   NotePropsV2,
   NoteUtilsV2,
   SchemaModuleOptsV2,
@@ -24,6 +25,20 @@ export function file2Schema(fpath: string): SchemaModulePropsV2 {
   ) as SchemaModuleOptsV2;
   return SchemaParserV2.parseRaw(schemaOpts, { root, fname });
 }
+export function string2Schema({
+  vault,
+  content,
+  fname,
+}: {
+  vault: DVault;
+  content: string;
+  fname: string;
+}) {
+  const schemaOpts = YAML.safeLoad(content, {
+    schema: YAML.JSON_SCHEMA,
+  }) as SchemaModuleOptsV2;
+  return SchemaParserV2.parseRaw(schemaOpts, { root: vault.fsPath, fname });
+}
 
 export function string2Note({
   content,

packages/dendron-cli/src/commands/__tests__/importPod.spec.ts

@@ -3,7 +3,7 @@ import {
   NodeTestUtils,
   writeYAML,
 } from "@dendronhq/common-server";
-import { FileImportPod, getPodConfigPath } from "@dendronhq/pods-core";
+import { getPodConfigPath, MarkdownImportPod } from "@dendronhq/pods-core";
 import fs, { ensureDirSync } from "fs-extra";
 import path from "path";
 import { ImportPodCLICommand } from "../importPod";
@@ -36,7 +36,7 @@ describe("import file pod", async () => {
   test("file import, no config", async () => {
     try {
       await ImportPodCLICommand.run({
-        podId: FileImportPod.id,
+        podId: MarkdownImportPod.id,
         wsRoot,
         vault,
       });
@@ -48,13 +48,13 @@ describe("import file pod", async () => {
   test("config present, default", async () => {
     const configPath = getPodConfigPath(
       path.join(wsRoot, "pods"),
-      FileImportPod
+      MarkdownImportPod
     );
     ensureDirSync(path.dirname(configPath));
     writeYAML(configPath, { src: importSrc });
 
     const cmd = await ImportPodCLICommand.run({
-      podId: FileImportPod.id,
+      podId: MarkdownImportPod.id,
       wsRoot,
       vault,
     });

packages/engine-server/src/__tests__/__snapshots__/enginev2.spec.ts.snap

@@ -557,34 +557,6 @@ Object {
 }
 `;
 
-exports[`engine, schema/ write/ update schema, add new prop to module: new schema file 1`] = `
-Object {
-  "imports": Array [],
-  "schemas": Array [
-    Object {
-      "children": Array [
-        "ch1",
-        "ch2",
-      ],
-      "id": "foo",
-      "parent": "root",
-      "title": "foo",
-    },
-    Object {
-      "children": Array [],
-      "id": "ch1",
-      "title": "ch1",
-    },
-    Object {
-      "children": Array [],
-      "id": "ch2",
-      "title": "ch2",
-    },
-  ],
-  "version": 1,
-}
-`;
-
 exports[`note and schema basics/ root and two notes 1`] = `
 Object {
   "foo": Object {

packages/engine-server/src/__tests__/enginev2.spec.ts

@@ -142,13 +142,6 @@ describe("engine, schema/", () => {
       // query should have same results
       const resp = await engine.querySchema("*");
       expect(resp.data.length).toEqual(2);
-
-      // should be written to file
-      const data = readYAML(path.join(vaultDir, "foo.schema.yml"));
-      expect(data).toMatchSnapshot("new schema file");
-      expect(data.schemas.length).toEqual(3);
-      // should have added new child
-      expect(_.find(data.schemas, { id: "foo" }).children.length).toEqual(2);
     });
 
     test("write new module", async () => {

packages/engine-server/src/drivers/file/storev2.ts

@@ -440,8 +440,9 @@ export class FileStorageV2 implements DStoreV2 {
 
   async updateSchema(schemaModule: SchemaModulePropsV2) {
     this.schemas[schemaModule.root.id] = schemaModule;
-    const vaultDir = this.vaults[0];
-    await schemaModuleProps2File(schemaModule, vaultDir, schemaModule.fname);
+    // const vaultDir = this.vaults[0];
+    // await schemaModuleProps2File(schemaModule, vaultDir, schemaModule.fname);
+    // TODO: update notes
   }
 
   async writeNote(
@@ -478,6 +479,8 @@ export class FileStorageV2 implements DStoreV2 {
   }
 
   async writeSchema(schemaModule: SchemaModulePropsV2) {
-    return this.updateSchema(schemaModule);
+    this.schemas[schemaModule.root.id] = schemaModule;
+    const vaultDir = this.vaults[0];
+    await schemaModuleProps2File(schemaModule, vaultDir, schemaModule.fname);
   }
 }

packages/engine-server/src/engineClient.ts

@@ -265,8 +265,10 @@ export class DendronEngineClient implements DEngineClientV2 {
     return _.defaults(out, { data: [] });
   }
 
-  async updateSchema(_schema: SchemaModulePropsV2): Promise<void> {
-    throw Error("not implemented");
+  async updateSchema(schema: SchemaModulePropsV2): Promise<void> {
+    await this.api.schemaUpdate({ schema, ws: this.ws });
+    await this.refreshSchemas([schema]);
+    return;
   }
 
   async writeSchema(schema: SchemaModulePropsV2): Promise<void> {

packages/plugin-core/src/utils.ts

@@ -1,6 +1,18 @@
+import {
+  DendronError,
+  DEngine,
+  DEngineClientV2,
+  DNodeUtils,
+  DNodeUtilsV2,
+  DVault,
+  NoteUtilsV2,
+  SchemaUtils,
+} from "@dendronhq/common-all";
 import { FileTestUtils, resolveTilde } from "@dendronhq/common-server";
 import fs from "fs-extra";
 import _ from "lodash";
+import _md from "markdown-it";
+import moment from "moment";
 import os from "os";
 import path from "path";
 import * as vscode from "vscode";
@@ -11,19 +23,8 @@ import {
   _noteAddBehaviorEnum,
 } from "./constants";
 import { FileItem } from "./external/fileutils/FileItem";
-import _md from "markdown-it";
-import { DendronWorkspace } from "./workspace";
-import {
-  DendronError,
-  DEngine,
-  DEngineClientV2,
-  DNodeUtils,
-  DNodeUtilsV2,
-  NoteUtilsV2,
-  SchemaUtils,
-} from "@dendronhq/common-all";
-import moment from "moment";
 import { EngineAPIService } from "./services/EngineAPIService";
+import { DendronWorkspace } from "./workspace";
 
 export class DisposableStore {
   private _toDispose = new Set<vscode.Disposable>();
@@ -489,4 +490,15 @@ export class DendronClientUtilsV2 {
     }
     return smod;
   };
+
+  static getVault({
+    dirname,
+  }: {
+    dirname: string;
+    engine: DEngineClientV2;
+  }): DVault {
+    return {
+      fsPath: dirname,
+    };
+  }
 }

packages/plugin-core/src/watchers/schemaWatcher.ts

@@ -0,0 +1,73 @@
+import { DEngineClientV2 } from "@dendronhq/common-all";
+import { string2Schema } from "@dendronhq/common-server";
+import _ from "lodash";
+import path from "path";
+import * as vscode from "vscode";
+import { Logger } from "../logger";
+import { DendronClientUtilsV2 } from "../utils";
+import { DendronWorkspace } from "../workspace";
+
+export class SchemaWatcher {
+  public watcher: vscode.FileSystemWatcher;
+  /**
+   * Should watching be paused
+   */
+  public pause: boolean;
+  public L = Logger;
+  public ws: DendronWorkspace;
+  public engine: DEngineClientV2;
+
+  constructor({ vaults }: { vaults: vscode.WorkspaceFolder[] }) {
+    const rootFolder = vaults[0];
+    const pattern = new vscode.RelativePattern(rootFolder, "*.schema.yml");
+    const watcher = vscode.workspace.createFileSystemWatcher(
+      pattern,
+      true,
+      false,
+      true
+    );
+    this.watcher = watcher;
+    this.ws = DendronWorkspace.instance();
+    this.engine = this.ws.getEngine();
+    this.pause = false;
+  }
+
+  activate(context: vscode.ExtensionContext) {
+    context.subscriptions.push(
+      this.watcher.onDidChange(this.onDidChange, this)
+    );
+  }
+
+  async onDidChange(uri: vscode.Uri) {
+    const ctx = "SchemaWatcher:onDidChange";
+    if (this.pause) {
+      return;
+    }
+    this.L.info({ ctx, uri });
+    const engine = DendronWorkspace.instance().getEngine();
+    const fname = path.basename(uri.fsPath, ".schema.yml");
+    const dirname = path.dirname(uri.fsPath);
+    const vault = DendronClientUtilsV2.getVault({ dirname, engine });
+    const document = await vscode.workspace.openTextDocument(uri);
+    const content = document.getText();
+
+    try {
+      const maybeSchema = string2Schema({ vault, content, fname });
+      await engine.updateSchema(maybeSchema);
+      vscode.window.showInformationMessage("schema updated");
+    } catch (err) {
+      if (err.msg) {
+        vscode.window.showErrorMessage(err.msg);
+      } else {
+        vscode.window.showErrorMessage(err.message);
+      }
+      return;
+    }
+  }
+
+  static refreshTree = _.debounce(() => {
+    const ctx = "refreshTree";
+    Logger.info({ ctx });
+    DendronWorkspace.instance().dendronTreeView?.treeProvider.refresh();
+  }, 100);
+}