@koishijs/plugin-database-memory 1.1.0 → 1.2.0

package/lib/browser.js

@@ -1 +1 @@
-var x=Object.defineProperty;var l=(y,t)=>x(y,"name",{value:t,configurable:!0});import{clone as p,Database as b,DriverError as v,makeArray as g,Model as m,noop as k,pick as $}from"koishi";import{executeEval as T,executeQuery as d,executeSort as S,executeUpdate as h}from"@koishijs/orm";var f=class{constructor(t,e){this.config=e;e.prefix||="koishi.database."}async start(t){for(let e in localStorage){if(!e.startsWith(this.config.prefix))break;let s=localStorage.getItem(e);if(!s)return;try{let r=JSON.parse(s);t[e.slice(this.config.prefix.length)]=r}catch{}}}async drop(t){if(t){localStorage.removeItem(this.config.prefix+t);return}for(let e in localStorage)e.startsWith(this.config.prefix)&&localStorage.removeItem(e)}async save(t,e){try{let s=JSON.stringify(e);localStorage.setItem(this.config.prefix+t,s)}catch{}}};l(f,"Storage");var u=class extends b{constructor(t,e={}){super(t);this.ctx=t;this.config=e;this.memory=this;this.#t={};e.storage&&(this.#e=new f(t,e))}#t;#e;async start(){await this.#e?.start(this.#t)}async $save(t){await this.#e?.save(t,this.#t[t])}stop(){}$table(t){return this.#t[t]||=[]}async drop(){this.#t={},await this.#e?.drop()}async stats(){return{}}$query(t,e){let s=this.resolveQuery(t,e);return this.$table(t).filter(r=>d(r,s))}async get(t,e,s){let{fields:r,limit:c=1/0,offset:i=0,sort:a={}}=this.resolveModifier(t,s);return S(this.$query(t,e),a).slice(i,i+c).map(o=>this.resolveData(t,o,r))}async set(t,e,s){s=this.resolveUpdate(t,s),this.$query(t,e).forEach(r=>h(r,s)),this.$save(t)}async remove(t,e){let s=this.resolveQuery(t,e);this.#t[t]=this.$table(t).filter(r=>!d(r,s)),this.$save(t)}async create(t,e){let s=this.$table(t),{primary:r,fields:c,autoInc:i}=this.model.config[t];if(e=this.model.format(t,p(e)),!Array.isArray(r)&&i&&!(r in e)){let o=s.length?Math.max(...s.map(n=>+n[r])):0;e[r]=o+1,m.Field.string.includes(c[r].type)&&(e[r]+="")}else if((await this.get(t,$(e,g(r)))).length)throw new v("duplicate-entry");let a=this.model.create(t,e);return s.push(a),this.$save(t),p(a)}async upsert(t,e,s){let r=g(s||this.model.config[t].primary);for(let c of e){let i=this.model.format(t,c),a=this.$table(t).find(o=>r.every(n=>o[n]===i[n]));if(a)h(a,i);else{let o=this.model.create(t);await this.create(t,h(o,i)).catch(k)}}this.$save(t)}async eval(t,e,s){let r=this.$query(t,s);return T(r,e)}};l(u,"MemoryDatabase");var N=u;export{u as MemoryDatabase,N as default};
+var n=Object.defineProperty;var t=(o,e)=>n(o,"name",{value:e,configurable:!0});import{Schema as i}from"koishi";import m from"@cosmotype/driver-memory";var y="MemoryDatabase",C=i.object({});function c(o,e){let r=new m(o.model,e);o.on("ready",()=>r.start()),o.on("dispose",()=>r.stop())}t(c,"apply");export{C as Config,c as apply,y as name};

package/lib/index.d.ts

@@ -1,30 +1,6 @@
-/// <reference types="koishi/lib" />
-import { Context, Database, Tables } from 'koishi';
-import { Modifier, Query } from '@koishijs/orm';
-import { Config } from './storage';
-declare module 'koishi' {
-    interface Database {
-        memory: MemoryDatabase;
-    }
-}
-export declare class MemoryDatabase extends Database {
-    #private;
-    ctx: Context;
-    config: Config;
-    memory: this;
-    constructor(ctx: Context, config?: Config);
-    start(): Promise<void>;
-    $save(name: string): Promise<void>;
-    stop(): void;
-    $table<K extends keyof Tables>(table: K): any[];
-    drop(): Promise<void>;
-    stats(): Promise<{}>;
-    $query(name: keyof Tables, query: Query): any[];
-    get(name: keyof Tables, query: Query, modifier?: Modifier): Promise<any[]>;
-    set(name: keyof Tables, query: Query, data: {}): Promise<void>;
-    remove(name: keyof Tables, query: Query): Promise<void>;
-    create<T extends keyof Tables>(name: T, data: any): Promise<Tables[T]>;
-    upsert(name: keyof Tables, data: any[], key: string | string[]): Promise<void>;
-    eval(name: keyof Tables, expr: any, query: Query): Promise<any>;
-}
-export default MemoryDatabase;
+import { Context, Schema } from 'koishi';
+import MemoryDriver from '@cosmotype/driver-memory';
+export declare const name = "MemoryDatabase";
+export declare type Config = MemoryDriver.Config;
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): void;

package/lib/node.js

@@ -8,8 +8,8 @@ var __markAsModule = (target) => __defProp(target, "__esModule", { value: true }
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   __markAsModule(target);
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
 var __reExport = (target, module2, desc) => {
   if (module2 && typeof module2 === "object" || typeof module2 === "function") {
@@ -22,200 +22,27 @@ var __reExport = (target, module2, desc) => {
 var __toModule = (module2) => {
   return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
 };
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
 
 // plugins/database/memory/src/index.ts
 __export(exports, {
-  MemoryDatabase: () => MemoryDatabase,
-  default: () => src_default
+  Config: () => Config,
+  apply: () => apply,
+  name: () => name
 });
 var import_koishi = __toModule(require("koishi"));
-var import_orm = __toModule(require("@koishijs/orm"));
-
-// plugins/database/memory/src/storage/node.ts
-var import_fs = __toModule(require("fs"));
-var import_path = __toModule(require("path"));
-var loaders = ["json", "yaml", "yml"];
-var Storage = class {
-  constructor(ctx, config) {
-    this.config = config;
-    config.loader || (config.loader = "json");
-    config.root || (config.root = (0, import_path.resolve)(ctx.app.baseDir, ".koishi/database"));
-    if (!loaders.includes(config.loader)) {
-      throw new Error(`unsupported loader "${config.loader}"`);
-    }
-  }
-  async start(tables) {
-    const { root, loader } = this.config;
-    await import_fs.promises.mkdir(root, { recursive: true });
-    const files = await import_fs.promises.readdir(root);
-    await Promise.all(files.map(async (filename) => {
-      const extension = (0, import_path.extname)(filename);
-      if (extension !== `.${loader}`)
-        return;
-      const buffer = await import_fs.promises.readFile((0, import_path.resolve)(root, filename));
-      try {
-        const data = await this.load(buffer, loader);
-        const name = filename.slice(0, filename.length - extension.length);
-        tables[name] = data;
-      } catch {
-      }
-    }));
-  }
-  async load(buffer, loader) {
-    if (loader === "json") {
-      return JSON.parse(buffer.toString());
-    } else if (loader === "yaml" || loader === "yml") {
-      const { load } = require("js-yaml");
-      return load(buffer.toString());
-    }
-  }
-  async drop(name) {
-    const { root, loader } = this.config;
-    if (name) {
-      await import_fs.promises.rm((0, import_path.resolve)(root, `${name}.${loader}`));
-    } else {
-      await import_fs.promises.rm(root, { recursive: true, force: true });
-    }
-  }
-  async save(name, table) {
-    const { root, loader } = this.config;
-    try {
-      const buffer = await this.dump(table, loader);
-      await import_fs.promises.writeFile((0, import_path.resolve)(root, `${name}.${loader}`), buffer);
-    } catch {
-    }
-  }
-  async dump(data, loader) {
-    if (loader === "json") {
-      return JSON.stringify(data);
-    } else if (loader === "yaml" || loader === "yml") {
-      const { dump } = require("js-yaml");
-      return dump(data);
-    }
-  }
-};
-__name(Storage, "Storage");
-
-// plugins/database/memory/src/index.ts
-var _store, _loader;
-var MemoryDatabase = class extends import_koishi.Database {
-  constructor(ctx, config = {}) {
-    super(ctx);
-    this.ctx = ctx;
-    this.config = config;
-    this.memory = this;
-    __privateAdd(this, _store, {});
-    __privateAdd(this, _loader, void 0);
-    if (config.storage) {
-      __privateSet(this, _loader, new Storage(ctx, config));
-    }
-  }
-  async start() {
-    var _a;
-    await ((_a = __privateGet(this, _loader)) == null ? void 0 : _a.start(__privateGet(this, _store)));
-  }
-  async $save(name) {
-    var _a;
-    await ((_a = __privateGet(this, _loader)) == null ? void 0 : _a.save(name, __privateGet(this, _store)[name]));
-  }
-  stop() {
-  }
-  $table(table) {
-    var _a;
-    return (_a = __privateGet(this, _store))[table] || (_a[table] = []);
-  }
-  async drop() {
-    var _a;
-    __privateSet(this, _store, {});
-    await ((_a = __privateGet(this, _loader)) == null ? void 0 : _a.drop());
-  }
-  async stats() {
-    return {};
-  }
-  $query(name, query) {
-    const expr = this.resolveQuery(name, query);
-    return this.$table(name).filter((row) => (0, import_orm.executeQuery)(row, expr));
-  }
-  async get(name, query, modifier) {
-    const { fields, limit = Infinity, offset = 0, sort = {} } = this.resolveModifier(name, modifier);
-    return (0, import_orm.executeSort)(this.$query(name, query), sort).slice(offset, offset + limit).map((row) => this.resolveData(name, row, fields));
-  }
-  async set(name, query, data) {
-    data = this.resolveUpdate(name, data);
-    this.$query(name, query).forEach((row) => (0, import_orm.executeUpdate)(row, data));
-    this.$save(name);
-  }
-  async remove(name, query) {
-    const expr = this.resolveQuery(name, query);
-    __privateGet(this, _store)[name] = this.$table(name).filter((row) => !(0, import_orm.executeQuery)(row, expr));
-    this.$save(name);
-  }
-  async create(name, data) {
-    const store = this.$table(name);
-    const { primary, fields, autoInc } = this.model.config[name];
-    data = this.model.format(name, (0, import_koishi.clone)(data));
-    if (!Array.isArray(primary) && autoInc && !(primary in data)) {
-      const max = store.length ? Math.max(...store.map((row) => +row[primary])) : 0;
-      data[primary] = max + 1;
-      if (import_koishi.Model.Field.string.includes(fields[primary].type)) {
-        data[primary] += "";
-      }
-    } else {
-      const duplicated = await this.get(name, (0, import_koishi.pick)(data, (0, import_koishi.makeArray)(primary)));
-      if (duplicated.length) {
-        throw new import_koishi.DriverError("duplicate-entry");
-      }
-    }
-    const copy = this.model.create(name, data);
-    store.push(copy);
-    this.$save(name);
-    return (0, import_koishi.clone)(copy);
-  }
-  async upsert(name, data, key) {
-    const keys = (0, import_koishi.makeArray)(key || this.model.config[name].primary);
-    for (const _item of data) {
-      const item = this.model.format(name, _item);
-      const row = this.$table(name).find((row2) => {
-        return keys.every((key2) => row2[key2] === item[key2]);
-      });
-      if (row) {
-        (0, import_orm.executeUpdate)(row, item);
-      } else {
-        const data2 = this.model.create(name);
-        await this.create(name, (0, import_orm.executeUpdate)(data2, item)).catch(import_koishi.noop);
-      }
-    }
-    this.$save(name);
-  }
-  async eval(name, expr, query) {
-    const table = this.$query(name, query);
-    return (0, import_orm.executeEval)(table, expr);
-  }
-};
-__name(MemoryDatabase, "MemoryDatabase");
-_store = new WeakMap();
-_loader = new WeakMap();
-var src_default = MemoryDatabase;
+var import_driver_memory = __toModule(require("@cosmotype/driver-memory"));
+var name = "MemoryDatabase";
+var Config = import_koishi.Schema.object({});
+function apply(ctx, config) {
+  const driver = new import_driver_memory.default(ctx.model, config);
+  ctx.on("ready", () => driver.start());
+  ctx.on("dispose", () => driver.stop());
+}
+__name(apply, "apply");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  MemoryDatabase
+  Config,
+  apply,
+  name
 });
 //# sourceMappingURL=node.js.map

package/lib/node.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["../src/index.ts", "../src/storage/node.ts"],
-  "sourcesContent": ["import { clone, Context, Database, Dict, DriverError, makeArray, Model, noop, pick, Tables } from 'koishi'\nimport { executeEval, executeQuery, executeSort, executeUpdate, Modifier, Query } from '@koishijs/orm'\nimport { Config, Storage } from './storage'\n\ndeclare module 'koishi' {\n  interface Database {\n    memory: MemoryDatabase\n  }\n}\n\nexport class MemoryDatabase extends Database {\n  public memory = this\n\n  #store: Dict<any[]> = {}\n  #loader: Storage\n\n  constructor(public ctx: Context, public config: Config = {}) {\n    super(ctx)\n\n    if (config.storage) {\n      this.#loader = new Storage(ctx, config)\n    }\n  }\n\n  async start() {\n    await this.#loader?.start(this.#store)\n  }\n\n  async $save(name: string) {\n    await this.#loader?.save(name, this.#store[name])\n  }\n\n  stop() {}\n\n  $table<K extends keyof Tables>(table: K) {\n    return this.#store[table] ||= []\n  }\n\n  async drop() {\n    this.#store = {}\n    await this.#loader?.drop()\n  }\n\n  async stats() {\n    return {}\n  }\n\n  $query(name: keyof Tables, query: Query) {\n    const expr = this.resolveQuery(name, query)\n    return this.$table(name).filter(row => executeQuery(row, expr))\n  }\n\n  async get(name: keyof Tables, query: Query, modifier?: Modifier) {\n    const { fields, limit = Infinity, offset = 0, sort = {} } = this.resolveModifier(name, modifier)\n    return executeSort(this.$query(name, query), sort)\n      .slice(offset, offset + limit)\n      .map(row => this.resolveData(name, row, fields))\n  }\n\n  async set(name: keyof Tables, query: Query, data: {}) {\n    data = this.resolveUpdate(name, data)\n    this.$query(name, query).forEach(row => executeUpdate(row, data))\n    this.$save(name)\n  }\n\n  async remove(name: keyof Tables, query: Query) {\n    const expr = this.resolveQuery(name, query)\n    this.#store[name] = this.$table(name)\n      .filter(row => !executeQuery(row, expr))\n    this.$save(name)\n  }\n\n  async create<T extends keyof Tables>(name: T, data: any) {\n    const store = this.$table(name)\n    const { primary, fields, autoInc } = this.model.config[name]\n    data = this.model.format(name, clone(data))\n    if (!Array.isArray(primary) && autoInc && !(primary in data)) {\n      const max = store.length ? Math.max(...store.map(row => +row[primary])) : 0\n      data[primary] = max + 1\n      if (Model.Field.string.includes(fields[primary].type)) {\n        data[primary] += ''\n      }\n    } else {\n      const duplicated = await this.get(name, pick(data, makeArray(primary)))\n      if (duplicated.length) {\n        throw new DriverError('duplicate-entry')\n      }\n    }\n    const copy = this.model.create(name, data)\n    store.push(copy)\n    this.$save(name)\n    return clone(copy)\n  }\n\n  async upsert(name: keyof Tables, data: any[], key: string | string[]) {\n    const keys = makeArray(key || this.model.config[name].primary)\n    for (const _item of data) {\n      const item = this.model.format(name, _item)\n      const row = this.$table(name).find(row => {\n        return keys.every(key => row[key] === item[key])\n      })\n      if (row) {\n        executeUpdate(row, item)\n      } else {\n        const data = this.model.create(name)\n        await this.create(name, executeUpdate(data, item)).catch(noop)\n      }\n    }\n    this.$save(name)\n  }\n\n  async eval(name: keyof Tables, expr: any, query: Query) {\n    const table = this.$query(name, query)\n    return executeEval(table, expr)\n  }\n}\n\nexport default MemoryDatabase\n", "import type * as yaml from 'js-yaml'\nimport { Context } from 'koishi'\nimport { promises as fs } from 'fs'\nimport { extname, resolve } from 'path'\n\ntype Loader = 'json' | 'yaml' | 'yml'\nconst loaders = ['json', 'yaml', 'yml']\n\nexport interface Config {\n  loader?: Loader\n  root?: string\n}\n\nexport class Storage {\n  constructor(ctx: Context, private config: Config) {\n    config.loader ||= 'json'\n    config.root ||= resolve(ctx.app.baseDir, '.koishi/database')\n    if (!loaders.includes(config.loader)) {\n      throw new Error(`unsupported loader \"${config.loader}\"`)\n    }\n  }\n\n  async start(tables: Record<string, any[]>) {\n    const { root, loader } = this.config\n    await fs.mkdir(root, { recursive: true })\n    const files = await fs.readdir(root)\n    await Promise.all(files.map(async (filename) => {\n      const extension = extname(filename)\n      if (extension !== `.${loader}`) return\n      const buffer = await fs.readFile(resolve(root, filename))\n      try {\n        const data = await this.load(buffer, loader)\n        const name = filename.slice(0, filename.length - extension.length)\n        tables[name] = data\n      } catch {}\n    }))\n  }\n\n  async load(buffer: Buffer, loader: Loader) {\n    if (loader === 'json') {\n      return JSON.parse(buffer.toString())\n    } else if (loader === 'yaml' || loader === 'yml') {\n      const { load } = require('js-yaml') as typeof yaml\n      return load(buffer.toString())\n    }\n  }\n\n  async drop(name?: string) {\n    const { root, loader } = this.config\n    if (name) {\n      await fs.rm(resolve(root, `${name}.${loader}`))\n    } else {\n      await fs.rm(root, { recursive: true, force: true })\n    }\n  }\n\n  async save(name: string, table: any[]) {\n    const { root, loader } = this.config\n    try {\n      const buffer = await this.dump(table, loader)\n      await fs.writeFile(resolve(root, `${name}.${loader}`), buffer)\n    } catch {}\n  }\n\n  async dump(data: any, loader: Loader) {\n    if (loader === 'json') {\n      return JSON.stringify(data)\n    } else if (loader === 'yaml' || loader === 'yml') {\n      const { dump } = require('js-yaml') as typeof yaml\n      return dump(data)\n    }\n  }\n}\n"],
-  "mappings": "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",
+  "sources": ["../src/index.ts"],
+  "sourcesContent": ["import { Context, Schema } from 'koishi'\nimport MemoryDriver from '@cosmotype/driver-memory'\n\nexport const name = 'MemoryDatabase'\n\nexport type Config = MemoryDriver.Config\n\nexport const Config: Schema<Config> = Schema.object({})\n\nexport function apply(ctx: Context, config: Config) {\n  const driver = new MemoryDriver(ctx.model, config)\n  ctx.on('ready', () => driver.start())\n  ctx.on('dispose', () => driver.stop())\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAgC;AAChC,2BAAyB;AAElB,IAAM,OAAO;AAIb,IAAM,SAAyB,qBAAO,OAAO;AAE7C,eAAe,KAAc,QAAgB;AAClD,QAAM,SAAS,IAAI,6BAAa,IAAI,OAAO;AAC3C,MAAI,GAAG,SAAS,MAAM,OAAO;AAC7B,MAAI,GAAG,WAAW,MAAM,OAAO;AAAA;AAHjB;",
   "names": []
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@koishijs/plugin-database-memory",
   "description": "A in-memory database implementation for Koishi",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "main": "lib/node.js",
   "module": "lib/browser.js",
   "typings": "lib/index.d.ts",
@@ -28,15 +28,9 @@
     "impl:database"
   ],
   "peerDependencies": {
-    "koishi": "^4.5.0"
-  },
-  "devDependencies": {
-    "@koishijs/database-tests": "^1.0.0",
-    "@koishijs/plugin-mock": "^1.0.3",
-    "@types/js-yaml": "^4.0.5",
-    "js-yaml": "^4.1.0"
+    "koishi": "^4.6.0"
   },
   "dependencies": {
-    "@koishijs/orm": "^1.0.0"
+    "@cosmotype/driver-memory": "^1.0.2"
   }
 }