@koishijs/plugin-database-memory 1.0.1 → 1.2.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/lib/browser.js +1 -145
- package/lib/browser.js.map +1 -1
- package/lib/index.d.ts +6 -32
- package/lib/node.js +17 -202
- package/lib/node.js.map +3 -3
- package/package.json +4 -13
package/lib/browser.js
CHANGED
|
@@ -1,145 +1 @@
|
|
|
1
|
-
var
|
|
2
|
-
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
|
|
3
|
-
|
|
4
|
-
// plugins/database/memory/src/index.ts
|
|
5
|
-
import { Database, Query, clone, makeArray, pick, Model, noop, KoishiError } from "koishi";
|
|
6
|
-
import { executeQuery, executeEval, executeUpdate, executeSort } from "@koishijs/orm-utils";
|
|
7
|
-
|
|
8
|
-
// plugins/database/memory/src/storage/browser.ts
|
|
9
|
-
var Storage = class {
|
|
10
|
-
constructor(ctx, config) {
|
|
11
|
-
this.config = config;
|
|
12
|
-
config.prefix ||= "koishi.database.";
|
|
13
|
-
}
|
|
14
|
-
async start(tables) {
|
|
15
|
-
for (const key in localStorage) {
|
|
16
|
-
if (!key.startsWith(this.config.prefix))
|
|
17
|
-
break;
|
|
18
|
-
const buffer = localStorage.getItem(key);
|
|
19
|
-
if (!buffer)
|
|
20
|
-
return;
|
|
21
|
-
try {
|
|
22
|
-
const data = JSON.parse(buffer);
|
|
23
|
-
tables[key.slice(this.config.prefix.length)] = data;
|
|
24
|
-
} catch {
|
|
25
|
-
}
|
|
26
|
-
}
|
|
27
|
-
}
|
|
28
|
-
async drop(name) {
|
|
29
|
-
if (name) {
|
|
30
|
-
localStorage.removeItem(this.config.prefix + name);
|
|
31
|
-
return;
|
|
32
|
-
}
|
|
33
|
-
for (const key in localStorage) {
|
|
34
|
-
if (key.startsWith(this.config.prefix)) {
|
|
35
|
-
localStorage.removeItem(key);
|
|
36
|
-
}
|
|
37
|
-
}
|
|
38
|
-
}
|
|
39
|
-
async save(name, table) {
|
|
40
|
-
try {
|
|
41
|
-
const buffer = JSON.stringify(table);
|
|
42
|
-
localStorage.setItem(this.config.prefix + name, buffer);
|
|
43
|
-
} catch {
|
|
44
|
-
}
|
|
45
|
-
}
|
|
46
|
-
};
|
|
47
|
-
__name(Storage, "Storage");
|
|
48
|
-
|
|
49
|
-
// plugins/database/memory/src/index.ts
|
|
50
|
-
var MemoryDatabase = class extends Database {
|
|
51
|
-
constructor(ctx, config = {}) {
|
|
52
|
-
super(ctx);
|
|
53
|
-
this.ctx = ctx;
|
|
54
|
-
this.config = config;
|
|
55
|
-
this.memory = this;
|
|
56
|
-
this.#store = {};
|
|
57
|
-
if (config.storage) {
|
|
58
|
-
this.#loader = new Storage(ctx, config);
|
|
59
|
-
}
|
|
60
|
-
}
|
|
61
|
-
#store;
|
|
62
|
-
#loader;
|
|
63
|
-
async start() {
|
|
64
|
-
await this.#loader?.start(this.#store);
|
|
65
|
-
}
|
|
66
|
-
async $save(name) {
|
|
67
|
-
await this.#loader?.save(name, this.#store[name]);
|
|
68
|
-
}
|
|
69
|
-
stop() {
|
|
70
|
-
}
|
|
71
|
-
$table(table) {
|
|
72
|
-
return this.#store[table] ||= [];
|
|
73
|
-
}
|
|
74
|
-
async drop() {
|
|
75
|
-
this.#store = {};
|
|
76
|
-
await this.#loader?.drop();
|
|
77
|
-
}
|
|
78
|
-
async stats() {
|
|
79
|
-
return {};
|
|
80
|
-
}
|
|
81
|
-
$query(name, query) {
|
|
82
|
-
const expr = this.ctx.model.resolveQuery(name, query);
|
|
83
|
-
return this.$table(name).filter((row) => executeQuery(row, expr));
|
|
84
|
-
}
|
|
85
|
-
async get(name, query, modifier) {
|
|
86
|
-
const { fields, limit = Infinity, offset = 0, sort = {} } = Query.resolveModifier(modifier);
|
|
87
|
-
return executeSort(this.$query(name, query), sort).map((row) => clone(pick(row, fields))).slice(offset, offset + limit);
|
|
88
|
-
}
|
|
89
|
-
async set(name, query, data) {
|
|
90
|
-
this.$query(name, query).forEach((row) => executeUpdate(row, data));
|
|
91
|
-
this.$save(name);
|
|
92
|
-
}
|
|
93
|
-
async remove(name, query) {
|
|
94
|
-
const expr = this.ctx.model.resolveQuery(name, query);
|
|
95
|
-
this.#store[name] = this.$table(name).filter((row) => !executeQuery(row, expr));
|
|
96
|
-
this.$save(name);
|
|
97
|
-
}
|
|
98
|
-
async create(name, data) {
|
|
99
|
-
const store = this.$table(name);
|
|
100
|
-
const { primary, fields, autoInc } = this.ctx.model.config[name];
|
|
101
|
-
data = clone(data);
|
|
102
|
-
if (!Array.isArray(primary) && autoInc && !(primary in data)) {
|
|
103
|
-
const max = store.length ? Math.max(...store.map((row) => +row[primary])) : 0;
|
|
104
|
-
data[primary] = max + 1;
|
|
105
|
-
if (Model.Field.string.includes(fields[primary].type)) {
|
|
106
|
-
data[primary] += "";
|
|
107
|
-
}
|
|
108
|
-
} else {
|
|
109
|
-
const duplicated = await this.get(name, pick(data, makeArray(primary)));
|
|
110
|
-
if (duplicated.length) {
|
|
111
|
-
throw new KoishiError("duplicate entry", "database.duplicate-entry");
|
|
112
|
-
}
|
|
113
|
-
}
|
|
114
|
-
const copy = { ...this.ctx.model.create(name), ...data };
|
|
115
|
-
store.push(copy);
|
|
116
|
-
this.$save(name);
|
|
117
|
-
return clone(copy);
|
|
118
|
-
}
|
|
119
|
-
async upsert(name, data, key) {
|
|
120
|
-
const keys = makeArray(key || this.ctx.model.config[name].primary);
|
|
121
|
-
for (const item of data) {
|
|
122
|
-
const row = this.$table(name).find((row2) => {
|
|
123
|
-
return keys.every((key2) => row2[key2] === item[key2]);
|
|
124
|
-
});
|
|
125
|
-
if (row) {
|
|
126
|
-
executeUpdate(row, item);
|
|
127
|
-
} else {
|
|
128
|
-
const data2 = this.ctx.model.create(name);
|
|
129
|
-
await this.create(name, executeUpdate(data2, item)).catch(noop);
|
|
130
|
-
}
|
|
131
|
-
}
|
|
132
|
-
this.$save(name);
|
|
133
|
-
}
|
|
134
|
-
async eval(name, expr, query) {
|
|
135
|
-
const table = this.$query(name, query);
|
|
136
|
-
return executeEval(table, expr);
|
|
137
|
-
}
|
|
138
|
-
};
|
|
139
|
-
__name(MemoryDatabase, "MemoryDatabase");
|
|
140
|
-
var src_default = MemoryDatabase;
|
|
141
|
-
export {
|
|
142
|
-
MemoryDatabase,
|
|
143
|
-
src_default as default
|
|
144
|
-
};
|
|
145
|
-
//# sourceMappingURL=browser.js.map
|
|
1
|
+
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/browser.js.map
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
{
|
|
2
2
|
"version": 3,
|
|
3
3
|
"sources": ["../src/index.ts", "../src/storage/browser.ts"],
|
|
4
|
-
"sourcesContent": ["import { Context, Database,
|
|
4
|
+
"sourcesContent": ["import { clone, Context, Database, Dict, KoishiError, makeArray, Model, noop, pick, Query, TableType } from 'koishi'\nimport { executeEval, executeQuery, executeSort, executeUpdate } from '@koishijs/orm-utils'\nimport { Config, Storage } from './storage'\n\ndeclare module 'koishi' {\n interface Database {\n memory: MemoryDatabase\n }\n\n interface Modules {\n 'database-memory': typeof import('.')\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 TableType>(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: TableType, query: Query) {\n const expr = this.ctx.model.resolveQuery(name, query)\n return this.$table(name).filter(row => executeQuery(row, expr))\n }\n\n async get(name: TableType, query: Query, modifier?: Query.Modifier) {\n const { fields, limit = Infinity, offset = 0, sort = {} } = Query.resolveModifier(modifier)\n return executeSort(this.$query(name, query), sort)\n .map(row => clone(pick(row, fields)))\n .slice(offset, offset + limit)\n }\n\n async set(name: TableType, query: Query, data: {}) {\n this.$query(name, query).forEach(row => executeUpdate(row, data))\n this.$save(name)\n }\n\n async remove(name: TableType, query: Query) {\n const expr = this.ctx.model.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(name: TableType, data: any) {\n const store = this.$table(name)\n const { primary, fields, autoInc } = this.ctx.model.config[name]\n data = 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 KoishiError('duplicate entry', 'database.duplicate-entry')\n }\n }\n const copy = { ...this.ctx.model.create(name), ...data }\n store.push(copy)\n this.$save(name)\n return clone(copy)\n }\n\n async upsert(name: TableType, data: any[], key: string | string[]) {\n const keys = makeArray(key || this.ctx.model.config[name].primary)\n for (const item of data) {\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.ctx.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: TableType, expr: any, query: Query) {\n const table = this.$query(name, query)\n return executeEval(table, expr)\n }\n}\n\nexport default MemoryDatabase\n", "import { Context } from 'koishi'\n\nexport interface Config {\n prefix?: string\n}\n\nexport class Storage {\n constructor(ctx: Context, private config: Config) {\n config.prefix ||= 'koishi.database.'\n }\n\n async start(tables: Record<string, any[]>) {\n for (const key in localStorage) {\n if (!key.startsWith(this.config.prefix)) break\n const buffer = localStorage.getItem(key)\n if (!buffer) return\n try {\n const data = JSON.parse(buffer)\n tables[key.slice(this.config.prefix.length)] = data\n } catch {}\n }\n }\n\n async drop(name?: string) {\n if (name) {\n localStorage.removeItem(this.config.prefix + name)\n return\n }\n\n for (const key in localStorage) {\n if (key.startsWith(this.config.prefix)) {\n localStorage.removeItem(key)\n }\n }\n }\n\n async save(name: string, table: any[]) {\n try {\n const buffer = JSON.stringify(table)\n localStorage.setItem(this.config.prefix + name, buffer)\n } catch {}\n }\n}\n"],
|
|
5
5
|
"mappings": "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",
|
|
6
6
|
"names": []
|
|
7
7
|
}
|
package/lib/index.d.ts
CHANGED
|
@@ -1,32 +1,6 @@
|
|
|
1
|
-
|
|
2
|
-
import
|
|
3
|
-
|
|
4
|
-
declare
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
}
|
|
8
|
-
interface Modules {
|
|
9
|
-
'database-memory': typeof import('.');
|
|
10
|
-
}
|
|
11
|
-
}
|
|
12
|
-
export declare class MemoryDatabase extends Database {
|
|
13
|
-
#private;
|
|
14
|
-
ctx: Context;
|
|
15
|
-
config: Config;
|
|
16
|
-
memory: this;
|
|
17
|
-
constructor(ctx: Context, config?: Config);
|
|
18
|
-
start(): Promise<void>;
|
|
19
|
-
$save(name: string): Promise<void>;
|
|
20
|
-
stop(): void;
|
|
21
|
-
$table<K extends TableType>(table: K): any[];
|
|
22
|
-
drop(): Promise<void>;
|
|
23
|
-
stats(): Promise<{}>;
|
|
24
|
-
$query(name: TableType, query: Query): any[];
|
|
25
|
-
get(name: TableType, query: Query, modifier?: Query.Modifier): Promise<Pick<any, string>[]>;
|
|
26
|
-
set(name: TableType, query: Query, data: {}): Promise<void>;
|
|
27
|
-
remove(name: TableType, query: Query): Promise<void>;
|
|
28
|
-
create(name: TableType, data: any): Promise<any>;
|
|
29
|
-
upsert(name: TableType, data: any[], key: string | string[]): Promise<void>;
|
|
30
|
-
eval(name: TableType, expr: any, query: Query): Promise<any>;
|
|
31
|
-
}
|
|
32
|
-
export default MemoryDatabase;
|
|
1
|
+
import { Context, Schema } from 'koishi';
|
|
2
|
+
import MemoryDriver from '@cosmotype/driver-memory';
|
|
3
|
+
export declare const name = "MemoryDatabase";
|
|
4
|
+
export declare type Config = MemoryDriver.Config;
|
|
5
|
+
export declare const Config: Schema<Config>;
|
|
6
|
+
export declare function apply(ctx: Context, config: Config): void;
|
package/lib/node.js
CHANGED
|
@@ -2,28 +2,14 @@ var __create = Object.create;
|
|
|
2
2
|
var __defProp = Object.defineProperty;
|
|
3
3
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
4
4
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
5
|
-
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
|
|
6
5
|
var __getProtoOf = Object.getPrototypeOf;
|
|
7
6
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
8
|
-
var __propIsEnum = Object.prototype.propertyIsEnumerable;
|
|
9
|
-
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
10
|
-
var __spreadValues = (a, b) => {
|
|
11
|
-
for (var prop in b || (b = {}))
|
|
12
|
-
if (__hasOwnProp.call(b, prop))
|
|
13
|
-
__defNormalProp(a, prop, b[prop]);
|
|
14
|
-
if (__getOwnPropSymbols)
|
|
15
|
-
for (var prop of __getOwnPropSymbols(b)) {
|
|
16
|
-
if (__propIsEnum.call(b, prop))
|
|
17
|
-
__defNormalProp(a, prop, b[prop]);
|
|
18
|
-
}
|
|
19
|
-
return a;
|
|
20
|
-
};
|
|
21
7
|
var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
|
|
22
8
|
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
|
|
23
9
|
var __export = (target, all) => {
|
|
24
10
|
__markAsModule(target);
|
|
25
|
-
for (var
|
|
26
|
-
__defProp(target,
|
|
11
|
+
for (var name2 in all)
|
|
12
|
+
__defProp(target, name2, { get: all[name2], enumerable: true });
|
|
27
13
|
};
|
|
28
14
|
var __reExport = (target, module2, desc) => {
|
|
29
15
|
if (module2 && typeof module2 === "object" || typeof module2 === "function") {
|
|
@@ -36,198 +22,27 @@ var __reExport = (target, module2, desc) => {
|
|
|
36
22
|
var __toModule = (module2) => {
|
|
37
23
|
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);
|
|
38
24
|
};
|
|
39
|
-
var __accessCheck = (obj, member, msg) => {
|
|
40
|
-
if (!member.has(obj))
|
|
41
|
-
throw TypeError("Cannot " + msg);
|
|
42
|
-
};
|
|
43
|
-
var __privateGet = (obj, member, getter) => {
|
|
44
|
-
__accessCheck(obj, member, "read from private field");
|
|
45
|
-
return getter ? getter.call(obj) : member.get(obj);
|
|
46
|
-
};
|
|
47
|
-
var __privateAdd = (obj, member, value) => {
|
|
48
|
-
if (member.has(obj))
|
|
49
|
-
throw TypeError("Cannot add the same private member more than once");
|
|
50
|
-
member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
|
|
51
|
-
};
|
|
52
|
-
var __privateSet = (obj, member, value, setter) => {
|
|
53
|
-
__accessCheck(obj, member, "write to private field");
|
|
54
|
-
setter ? setter.call(obj, value) : member.set(obj, value);
|
|
55
|
-
return value;
|
|
56
|
-
};
|
|
57
25
|
|
|
58
26
|
// plugins/database/memory/src/index.ts
|
|
59
27
|
__export(exports, {
|
|
60
|
-
|
|
61
|
-
|
|
28
|
+
Config: () => Config,
|
|
29
|
+
apply: () => apply,
|
|
30
|
+
name: () => name
|
|
62
31
|
});
|
|
63
32
|
var import_koishi = __toModule(require("koishi"));
|
|
64
|
-
var
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
config.loader || (config.loader = "json");
|
|
74
|
-
config.root || (config.root = (0, import_path.resolve)(ctx.app.baseDir, ".koishi/database"));
|
|
75
|
-
if (!loaders.includes(config.loader)) {
|
|
76
|
-
throw new Error(`unsupported loader "${config.loader}"`);
|
|
77
|
-
}
|
|
78
|
-
}
|
|
79
|
-
async start(tables) {
|
|
80
|
-
const { root, loader } = this.config;
|
|
81
|
-
await import_fs.promises.mkdir(root, { recursive: true });
|
|
82
|
-
const files = await import_fs.promises.readdir(root);
|
|
83
|
-
await Promise.all(files.map(async (filename) => {
|
|
84
|
-
const extension = (0, import_path.extname)(filename);
|
|
85
|
-
if (extension !== loader)
|
|
86
|
-
return;
|
|
87
|
-
const buffer = await import_fs.promises.readFile(filename);
|
|
88
|
-
try {
|
|
89
|
-
const data = await this.load(buffer, loader);
|
|
90
|
-
const name = filename.slice(0, -1 - extension.length);
|
|
91
|
-
tables[name] = data;
|
|
92
|
-
} catch {
|
|
93
|
-
}
|
|
94
|
-
}));
|
|
95
|
-
}
|
|
96
|
-
async load(buffer, loader) {
|
|
97
|
-
if (loader === "json") {
|
|
98
|
-
return JSON.parse(buffer.toString());
|
|
99
|
-
} else if (loader === "yaml" || loader === "yml") {
|
|
100
|
-
const { load } = require("js-yaml");
|
|
101
|
-
return load(buffer.toString());
|
|
102
|
-
}
|
|
103
|
-
}
|
|
104
|
-
async drop(name) {
|
|
105
|
-
const { root, loader } = this.config;
|
|
106
|
-
if (name) {
|
|
107
|
-
await import_fs.promises.rm((0, import_path.resolve)(root, `${name}.${loader}`));
|
|
108
|
-
} else {
|
|
109
|
-
await import_fs.promises.rm(root, { recursive: true, force: true });
|
|
110
|
-
}
|
|
111
|
-
}
|
|
112
|
-
async save(name, table) {
|
|
113
|
-
const { root, loader } = this.config;
|
|
114
|
-
try {
|
|
115
|
-
const buffer = await this.dump(table, loader);
|
|
116
|
-
await import_fs.promises.writeFile((0, import_path.resolve)(root, `${name}.${loader}`), buffer);
|
|
117
|
-
} catch {
|
|
118
|
-
}
|
|
119
|
-
}
|
|
120
|
-
async dump(data, loader) {
|
|
121
|
-
if (loader === "json") {
|
|
122
|
-
return JSON.stringify(data);
|
|
123
|
-
} else if (loader === "yaml" || loader === "yml") {
|
|
124
|
-
const { dump } = require("js-yaml");
|
|
125
|
-
return dump(data);
|
|
126
|
-
}
|
|
127
|
-
}
|
|
128
|
-
};
|
|
129
|
-
__name(Storage, "Storage");
|
|
130
|
-
|
|
131
|
-
// plugins/database/memory/src/index.ts
|
|
132
|
-
var _store, _loader;
|
|
133
|
-
var MemoryDatabase = class extends import_koishi.Database {
|
|
134
|
-
constructor(ctx, config = {}) {
|
|
135
|
-
super(ctx);
|
|
136
|
-
this.ctx = ctx;
|
|
137
|
-
this.config = config;
|
|
138
|
-
this.memory = this;
|
|
139
|
-
__privateAdd(this, _store, {});
|
|
140
|
-
__privateAdd(this, _loader, void 0);
|
|
141
|
-
if (config.storage) {
|
|
142
|
-
__privateSet(this, _loader, new Storage(ctx, config));
|
|
143
|
-
}
|
|
144
|
-
}
|
|
145
|
-
async start() {
|
|
146
|
-
var _a;
|
|
147
|
-
await ((_a = __privateGet(this, _loader)) == null ? void 0 : _a.start(__privateGet(this, _store)));
|
|
148
|
-
}
|
|
149
|
-
async $save(name) {
|
|
150
|
-
var _a;
|
|
151
|
-
await ((_a = __privateGet(this, _loader)) == null ? void 0 : _a.save(name, __privateGet(this, _store)[name]));
|
|
152
|
-
}
|
|
153
|
-
stop() {
|
|
154
|
-
}
|
|
155
|
-
$table(table) {
|
|
156
|
-
var _a;
|
|
157
|
-
return (_a = __privateGet(this, _store))[table] || (_a[table] = []);
|
|
158
|
-
}
|
|
159
|
-
async drop() {
|
|
160
|
-
var _a;
|
|
161
|
-
__privateSet(this, _store, {});
|
|
162
|
-
await ((_a = __privateGet(this, _loader)) == null ? void 0 : _a.drop());
|
|
163
|
-
}
|
|
164
|
-
async stats() {
|
|
165
|
-
return {};
|
|
166
|
-
}
|
|
167
|
-
$query(name, query) {
|
|
168
|
-
const expr = this.ctx.model.resolveQuery(name, query);
|
|
169
|
-
return this.$table(name).filter((row) => (0, import_orm_utils.executeQuery)(row, expr));
|
|
170
|
-
}
|
|
171
|
-
async get(name, query, modifier) {
|
|
172
|
-
const { fields, limit = Infinity, offset = 0, sort = {} } = import_koishi.Query.resolveModifier(modifier);
|
|
173
|
-
return (0, import_orm_utils.executeSort)(this.$query(name, query), sort).map((row) => (0, import_koishi.clone)((0, import_koishi.pick)(row, fields))).slice(offset, offset + limit);
|
|
174
|
-
}
|
|
175
|
-
async set(name, query, data) {
|
|
176
|
-
this.$query(name, query).forEach((row) => (0, import_orm_utils.executeUpdate)(row, data));
|
|
177
|
-
this.$save(name);
|
|
178
|
-
}
|
|
179
|
-
async remove(name, query) {
|
|
180
|
-
const expr = this.ctx.model.resolveQuery(name, query);
|
|
181
|
-
__privateGet(this, _store)[name] = this.$table(name).filter((row) => !(0, import_orm_utils.executeQuery)(row, expr));
|
|
182
|
-
this.$save(name);
|
|
183
|
-
}
|
|
184
|
-
async create(name, data) {
|
|
185
|
-
const store = this.$table(name);
|
|
186
|
-
const { primary, fields, autoInc } = this.ctx.model.config[name];
|
|
187
|
-
data = (0, import_koishi.clone)(data);
|
|
188
|
-
if (!Array.isArray(primary) && autoInc && !(primary in data)) {
|
|
189
|
-
const max = store.length ? Math.max(...store.map((row) => +row[primary])) : 0;
|
|
190
|
-
data[primary] = max + 1;
|
|
191
|
-
if (import_koishi.Model.Field.string.includes(fields[primary].type)) {
|
|
192
|
-
data[primary] += "";
|
|
193
|
-
}
|
|
194
|
-
} else {
|
|
195
|
-
const duplicated = await this.get(name, (0, import_koishi.pick)(data, (0, import_koishi.makeArray)(primary)));
|
|
196
|
-
if (duplicated.length) {
|
|
197
|
-
throw new import_koishi.KoishiError("duplicate entry", "database.duplicate-entry");
|
|
198
|
-
}
|
|
199
|
-
}
|
|
200
|
-
const copy = __spreadValues(__spreadValues({}, this.ctx.model.create(name)), data);
|
|
201
|
-
store.push(copy);
|
|
202
|
-
this.$save(name);
|
|
203
|
-
return (0, import_koishi.clone)(copy);
|
|
204
|
-
}
|
|
205
|
-
async upsert(name, data, key) {
|
|
206
|
-
const keys = (0, import_koishi.makeArray)(key || this.ctx.model.config[name].primary);
|
|
207
|
-
for (const item of data) {
|
|
208
|
-
const row = this.$table(name).find((row2) => {
|
|
209
|
-
return keys.every((key2) => row2[key2] === item[key2]);
|
|
210
|
-
});
|
|
211
|
-
if (row) {
|
|
212
|
-
(0, import_orm_utils.executeUpdate)(row, item);
|
|
213
|
-
} else {
|
|
214
|
-
const data2 = this.ctx.model.create(name);
|
|
215
|
-
await this.create(name, (0, import_orm_utils.executeUpdate)(data2, item)).catch(import_koishi.noop);
|
|
216
|
-
}
|
|
217
|
-
}
|
|
218
|
-
this.$save(name);
|
|
219
|
-
}
|
|
220
|
-
async eval(name, expr, query) {
|
|
221
|
-
const table = this.$query(name, query);
|
|
222
|
-
return (0, import_orm_utils.executeEval)(table, expr);
|
|
223
|
-
}
|
|
224
|
-
};
|
|
225
|
-
__name(MemoryDatabase, "MemoryDatabase");
|
|
226
|
-
_store = new WeakMap();
|
|
227
|
-
_loader = new WeakMap();
|
|
228
|
-
var src_default = MemoryDatabase;
|
|
33
|
+
var import_driver_memory = __toModule(require("@cosmotype/driver-memory"));
|
|
34
|
+
var name = "MemoryDatabase";
|
|
35
|
+
var Config = import_koishi.Schema.object({});
|
|
36
|
+
function apply(ctx, config) {
|
|
37
|
+
const driver = new import_driver_memory.default(ctx.model, config);
|
|
38
|
+
ctx.on("ready", () => driver.start());
|
|
39
|
+
ctx.on("dispose", () => driver.stop());
|
|
40
|
+
}
|
|
41
|
+
__name(apply, "apply");
|
|
229
42
|
// Annotate the CommonJS export names for ESM import in node:
|
|
230
43
|
0 && (module.exports = {
|
|
231
|
-
|
|
44
|
+
Config,
|
|
45
|
+
apply,
|
|
46
|
+
name
|
|
232
47
|
});
|
|
233
48
|
//# sourceMappingURL=node.js.map
|
package/lib/node.js.map
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
{
|
|
2
2
|
"version": 3,
|
|
3
|
-
"sources": ["../src/index.ts"
|
|
4
|
-
"sourcesContent": ["import { Context,
|
|
5
|
-
"mappings": "
|
|
3
|
+
"sources": ["../src/index.ts"],
|
|
4
|
+
"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"],
|
|
5
|
+
"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;",
|
|
6
6
|
"names": []
|
|
7
7
|
}
|
package/package.json
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@koishijs/plugin-database-memory",
|
|
3
3
|
"description": "A in-memory database implementation for Koishi",
|
|
4
|
-
"version": "1.0
|
|
4
|
+
"version": "1.2.0",
|
|
5
5
|
"main": "lib/node.js",
|
|
6
6
|
"module": "lib/browser.js",
|
|
7
7
|
"typings": "lib/index.d.ts",
|
|
@@ -20,9 +20,6 @@
|
|
|
20
20
|
"homepage": "https://koishi.js.org/plugins/other/database",
|
|
21
21
|
"keywords": [
|
|
22
22
|
"bot",
|
|
23
|
-
"qqbot",
|
|
24
|
-
"cqhttp",
|
|
25
|
-
"coolq",
|
|
26
23
|
"chatbot",
|
|
27
24
|
"koishi",
|
|
28
25
|
"plugin",
|
|
@@ -31,15 +28,9 @@
|
|
|
31
28
|
"impl:database"
|
|
32
29
|
],
|
|
33
30
|
"peerDependencies": {
|
|
34
|
-
"koishi": "^4.
|
|
35
|
-
},
|
|
36
|
-
"devDependencies": {
|
|
37
|
-
"@koishijs/database-tests": "^1.0.0",
|
|
38
|
-
"@koishijs/plugin-mock": "^1.0.2",
|
|
39
|
-
"@types/js-yaml": "^4.0.5",
|
|
40
|
-
"js-yaml": "^4.1.0"
|
|
31
|
+
"koishi": "^4.6.0"
|
|
41
32
|
},
|
|
42
33
|
"dependencies": {
|
|
43
|
-
"@
|
|
34
|
+
"@cosmotype/driver-memory": "^1.0.2"
|
|
44
35
|
}
|
|
45
|
-
}
|
|
36
|
+
}
|