@k3000/store 0.1.0

package/generator.mjs

@@ -0,0 +1,1357 @@
+import {copyFileSync, existsSync, mkdirSync, readdirSync, statSync, writeFileSync} from "node:fs";
+import {buffer, string, Storage, TypeLen} from './architect.mjs'
+import {resolve} from 'node:path'
+
+const modulePath = import.meta.url.endsWith('?test=true') ? '../../architect.mjs' : 'dmb3/architect.mjs'
+const modulePath2 = import.meta.url.endsWith('?test=true') ? '../../generator.mjs' : 'dmb3'
+
+class Enum {
+
+    init() {
+
+        let index = 0
+
+        for (let key of Object.keys(this)) {
+
+            Object.defineProperty(this, Number.isSafeInteger(this[key]) && this[key] > index ? index = this[key] : this[key] = index, {
+                value: key,
+                enumerable: false
+            })
+
+            index++
+        }
+    }
+}
+
+class TypeMap extends Enum {
+    id
+    uint
+    int
+    bigUint
+    bigint
+    time
+    float
+    string
+    buffer
+    text
+
+    constructor() {
+
+        super().init()
+    }
+}
+
+const typeMap = new TypeMap()
+
+const TimeAttr = {
+    now: -1,
+    update: -2,
+}
+
+const SCOPE = {}
+
+export const bigintSerialize = (_, value) => typeof value === "bigint" ? value.toString() : value
+
+class Type {
+
+    #type
+    #index
+    #value
+    #length
+    #remark
+    #step
+
+    constructor(type, remark) {
+
+        this.#type = type;
+        this.#remark = string(remark || '');
+    }
+
+    index(scope, support) {
+
+        if (scope === SCOPE) {
+
+            this.#index = !!support
+        }
+
+        return this;
+    }
+
+    value(scope, value) {
+
+        if (scope === SCOPE) {
+
+            this.#value = value
+        }
+
+        return this;
+    }
+
+    length(scope, length) {
+
+        if (scope === SCOPE) {
+
+            length = Number.parseInt(length) || 1
+
+            this.#length = length > 0 ? length : 1
+        }
+
+        return this;
+    }
+
+    step(scope, step) {
+
+        if (scope === SCOPE) {
+
+            step = parseFloat(step) || 1
+
+            this.#step = step > 0 ? step : 1
+        }
+
+        return this;
+    }
+
+    remark(remark = '') {
+
+        this.#remark = string(remark || '')
+
+        return this;
+    }
+
+    toJSON() {
+
+        const obj = {
+            type: this.#type,
+            remark: this.#remark,
+        }
+
+        if (this.#index) {
+
+            obj.index = []
+        }
+
+        if (this.#value !== undefined) {
+
+            obj.value = this.#value
+        }
+
+        if (this.#length !== undefined) {
+
+            obj.length = this.#length
+        }
+
+        if (this.#step !== undefined) {
+
+            obj.step = this.#step
+        }
+
+        return obj
+    }
+
+    toString() {
+
+        return JSON.stringify(this.toJSON(), bigintSerialize)
+    }
+}
+
+export const Id = remark => new class Id extends Type {
+
+    constructor() {
+
+        super(typeMap.id, remark);
+
+        super.index(SCOPE, true)
+        super.value(SCOPE, 1)
+        super.step(SCOPE, 1)
+        super.length(SCOPE, TypeLen.id)
+    }
+
+    index(support = true) {
+
+        return super.index(SCOPE, support);
+    }
+
+    value(value = 0) {
+
+        return super.value(SCOPE, Number.parseInt(value) || 0);
+    }
+
+    step(step = 1) {
+
+        step = Number.parseInt(step) || 1
+
+        return super.step(SCOPE, step > 0 ? step : 1);
+    }
+
+}()
+
+/**
+ * @param {1 | 2 | 3 | 4 | String} size
+ * @constructor
+ */
+export const Uint = size => new class Uint extends Type {
+
+    constructor() {
+
+        let remark = ''
+
+        if (typeof size === "string") {
+
+            remark = size
+            size = TypeLen.uint
+
+        } else if (Number.isInteger(size)) {
+
+            size = Math.round(size)
+
+            if (size < 1) size = 1
+            else if (size > TypeLen.uint) size = TypeLen.uint
+
+        } else {
+
+            size = TypeLen.uint
+        }
+
+        super(typeMap.uint, remark);
+
+        super.length(SCOPE, size)
+    }
+
+    index(support = true) {
+
+        return super.index(SCOPE, support);
+    }
+
+    value(value = 0) {
+
+        value = Number.parseInt(value) || 0
+
+        return super.value(SCOPE, value < 0 ? 0 : value);
+    }
+
+    step(step = 1) {
+
+        step = Number.parseInt(step) || 1
+
+        return super.step(SCOPE, step > 0 ? step : 1);
+    }
+
+}()
+
+/**
+ * @param {1 | 2 | 3 | 4 | String} size
+ * @constructor
+ */
+export const Int = size => new class Int extends Type {
+
+    constructor() {
+
+        let remark = ''
+
+        if (typeof size === "string") {
+
+            remark = size
+            size = TypeLen.int
+
+        } else if (Number.isInteger(size)) {
+
+            size = Math.round(size)
+
+            if (size < 1) size = 1
+            else if (size > TypeLen.int) size = TypeLen.int
+
+        } else {
+
+            size = TypeLen.int
+        }
+
+        super(typeMap.int, remark);
+
+        super.length(SCOPE, size)
+    }
+
+    index(support = true) {
+
+        return super.index(SCOPE, support);
+    }
+
+    value(value = 0) {
+
+        return super.value(SCOPE, Number.parseInt(value) || 0);
+    }
+
+    step(step = 1) {
+
+        step = Number.parseInt(step) || 1
+
+        return super.step(SCOPE, step === 0 ? 1 : step);
+    }
+
+}()
+
+export const BigUint = remark => new class BigUint extends Type {
+
+    constructor() {
+
+        super(typeMap.bigUint, remark);
+
+        super.length(SCOPE, TypeLen.bigUint)
+    }
+
+    index(support = true) {
+
+        return super.index(SCOPE, support);
+    }
+
+    value(value = 0) {
+
+        return super.value(SCOPE, BigInt(value || 0));
+    }
+
+    step(step = 1) {
+
+        step = BigInt(step || 1)
+
+        return super.step(SCOPE, step === 0n ? 1n : step);
+    }
+
+}()
+
+export const Bigint = remark => new class Bigint extends Type {
+
+    constructor() {
+
+        super(typeMap.bigint, remark);
+
+        super.length(SCOPE, TypeLen.bigint)
+    }
+
+    index(support = true) {
+
+        return super.index(SCOPE, support);
+    }
+
+    value(value = 0) {
+
+        return super.value(SCOPE, BigInt(value || 0));
+    }
+
+    step(step = 1) {
+
+        step = BigInt(step || 1)
+
+        return super.step(SCOPE, step === 0n ? 1n : step);
+    }
+
+}()
+
+export const Time = remark => new class Time extends Type {
+
+    constructor() {
+
+        super(typeMap.time, remark);
+
+        super.length(SCOPE, TypeLen.time)
+    }
+
+    index(support = true) {
+
+        return super.index(SCOPE, support);
+    }
+
+    value(value = 0) {
+
+        if (typeof value === "string" && Reflect.has(TimeAttr, value)) {
+
+            return super.value(SCOPE, TimeAttr[value])
+
+        } else {
+
+            value = Number.parseInt(value) || 0
+
+            return super.value(SCOPE, value > 0 ? value : 0);
+        }
+    }
+
+}()
+
+Object.defineProperties(Time, {
+    now: {
+        value: 'now',
+        configurable: false,
+        writable: false,
+    },
+    update: {
+        value: 'update',
+        configurable: false,
+        writable: false,
+    }
+})
+
+export const Float = remark => new class Float extends Type {
+
+    constructor() {
+
+        super(typeMap.float, remark);
+
+        super.length(SCOPE, TypeLen.float)
+    }
+
+    index(support = true) {
+
+        return super.index(SCOPE, support);
+    }
+
+    value(value = 0) {
+
+        return super.value(SCOPE, parseFloat(value) || 0);
+    }
+
+    step(step = 1) {
+
+        step = parseFloat(step) || 1
+
+        return super.step(SCOPE, step === 0 ? 1 : step);
+    }
+
+}()
+
+export const String = remark => new class String extends Type {
+
+    constructor() {
+
+        super(typeMap.string, remark);
+
+        super.length(SCOPE, TypeLen.string)
+    }
+
+    index(support = true) {
+
+        return super.index(SCOPE, support);
+    }
+
+    value(value = '') {
+
+        return super.value(SCOPE, string(value));
+    }
+
+    length(length) {
+
+        length = Number.parseInt(length) || TypeLen.string
+
+        return super.length(SCOPE, length > 0 ? length : TypeLen.string);
+    }
+
+}()
+
+export const Buffer = remark => new class Buffer extends Type {
+
+    constructor() {
+
+        super(typeMap.buffer, remark);
+
+        super.length(SCOPE, TypeLen.buffer)
+    }
+
+}()
+
+export const Text = remark => new class Text extends Type {
+
+    constructor() {
+
+        super(typeMap.text, remark);
+
+        super.length(SCOPE, TypeLen.text)
+    }
+
+}()
+
+export const struct = (storage, remark) => {
+
+    const struct = {}, base = storage.struct.base
+
+    for (const [key, value] of Object.entries(storage.struct.extra)) {
+
+        struct[key] = {[remark]: value.remark}
+
+        for (const [k, v] of Object.entries(base[key])) {
+
+            const item = {type: typeMap[v.type]}
+
+            if (Reflect.has(v, 'remark')) {
+
+                item.remark = v.remark
+            }
+
+            if (v.index) {
+
+                item.index = true
+            }
+
+            if (v.step) {
+
+                item.step = v.step
+            }
+
+            if (Reflect.has(v, 'value')) {
+
+                item.default = v.type === typeMap.time ? v.value === TimeAttr.now ? 'now' : v.value === TimeAttr.update ? 'update' : v.value : v.value
+            }
+
+            if ([typeMap.uint, typeMap.int, typeMap.string].includes(v.type)) {
+
+                item.length = v.length
+            }
+
+            struct[key][k] = item
+        }
+    }
+
+    return struct
+}
+
+const updateColPos = (base, extra) => {
+
+    let position = 0
+
+    for (const value of Object.values(base)) {
+
+        value.position = position
+
+        position += value.length
+    }
+
+    extra.length = position
+}
+
+function appendSet(name, set, remark = '') {
+
+    if (!Reflect.has(this.curr.struct.base, name)) {
+
+        console.log('append set:', name)
+
+        this.curr.struct.base[name] = {}
+        this.curr.struct.extra[name] = {remark}
+        this.curr.record.idle[name] = []
+        this.curr.record.index[name] = {}
+        this.curr.record.value[name] = {}
+        this.curr.record.record[name] = []
+
+        for (let [key, value] of Object.entries(set)) {
+
+            if (value instanceof Type) {
+
+                value = value.toJSON()
+
+            } else if (this.types.includes(value)) {
+
+                value = value().toJSON()
+            }
+
+            console.log('  append col:', key)
+
+            this.curr.struct.base[name][key] = value
+
+            if (value.index) {
+
+                this.curr.record.index[name][key] = []
+            }
+
+            if (value.step) {
+
+                this.curr.record.value[name][key] = value.value
+            }
+        }
+
+        updateColPos(this.curr.struct.base[name], this.curr.struct.extra[name])
+    }
+}
+
+function updateCol(name, set) {
+
+    if (Reflect.has(this.curr.struct.base, name)) {
+
+        console.log('current set:', name)
+
+        for (let [key, value] of Object.entries(set)) {
+
+            if (value instanceof Type) {
+
+                value = value.toJSON()
+
+            } else if (this.types.includes(value)) {
+
+                value = value().toJSON()
+            }
+
+            console.log(`  ${Reflect.has(this.curr.struct.base[name], key) ? 'update' : 'append'} col:`, key)
+
+            this.curr.struct.base[name][key] = value
+
+            if (value.index) {
+
+                this.curr.record.index[name][key] = []
+            }
+
+            if (value.step) {
+
+                this.curr.record.value[name][key] = value.value
+            }
+        }
+
+        updateColPos(this.curr.struct.base[name], this.curr.struct.extra[name])
+
+        this.updateSet.add(name)
+    }
+}
+
+function renameSet(name, newName) {
+
+    if (typeof newName === "string"
+        && Reflect.has(this.curr.struct.base, name)
+        && !Reflect.has(this.curr.struct.base, newName)) {
+
+        console.log(`rename set: ${name} -> ${newName}`)
+
+        this.curr.struct.base[newName] = this.curr.struct.base[name]
+
+        delete this.curr.struct.base[name]
+
+        this.curr.struct.extra[newName] = this.curr.struct.extra[name]
+
+        delete this.curr.struct.extra[name]
+
+        this.curr.record.idle[newName] = this.curr.record.idle[name]
+
+        delete this.curr.record.idle[name]
+
+        this.curr.record.index[newName] = this.curr.record.index[name]
+
+        delete this.curr.record.index[name]
+
+        this.curr.record.value[newName] = this.curr.record.value[name]
+
+        delete this.curr.record.value[name]
+
+        this.curr.record.record[newName] = this.curr.record.record[name]
+
+        delete this.curr.record.record[name]
+    }
+}
+
+function renameCol(name, set) {
+
+    if (Reflect.has(this.curr.struct.base, name)) {
+
+        for (let [key, newKey] of Object.entries(set)) {
+
+            if (typeof newKey === "string"
+                && Reflect.has(this.curr.struct.base[name], key)
+                && !Reflect.has(this.curr.struct.base[name], newKey)) {
+
+                console.log(`rename ${name} col: ${key} -> ${newKey}`)
+
+                this.curr.struct.base[name][newKey] = this.curr.struct.base[name][key]
+
+                delete this.curr.struct.base[name][key]
+
+                this.curr.struct.extra[name][newKey] = this.curr.struct.extra[name][key]
+
+                delete this.curr.struct.extra[name][key]
+
+                this.curr.record.idle[name][newKey] = this.curr.record.idle[name][key]
+
+                delete this.curr.record.idle[name][key]
+
+                this.curr.record.index[name][newKey] = this.curr.record.index[name][key]
+
+                delete this.curr.record.index[name][key]
+
+                this.curr.record.value[name][newKey] = this.curr.record.value[name][key]
+
+                delete this.curr.record.value[name][key]
+
+                this.curr.record.record[name][newKey] = this.curr.record.record[name][key]
+
+                delete this.curr.record.record[name][key]
+            }
+        }
+    }
+}
+
+function deleteSet(name) {
+
+    if (Reflect.has(this.curr.struct.base, name)) {
+
+        console.log(`delete set: ${name}`)
+
+        delete this.curr.struct.base[name]
+        delete this.curr.struct.extra[name]
+        delete this.curr.record.idle[name]
+        delete this.curr.record.index[name]
+        delete this.curr.record.value[name]
+        delete this.curr.record.record[name]
+    }
+}
+
+function deleteCol(name, col) {
+
+    if (Reflect.has(this.curr.struct.base, name)
+        && Reflect.has(this.curr.struct.base[name], col)) {
+
+        console.log(`delete ${name} col: ${col}`)
+
+        delete this.curr.struct.base[name][col]
+        delete this.curr.struct.extra[name][col]
+        delete this.curr.record.idle[name][col]
+        delete this.curr.record.index[name][col]
+        delete this.curr.record.value[name][col]
+        delete this.curr.record.record[name][col]
+
+        updateColPos(this.curr.struct.base[name], this.curr.struct.extra[name])
+
+        this.updateSet.add(name)
+    }
+}
+
+function updateSetRemark(name, remark) {
+
+    if (Reflect.has(this.curr.struct.base, name)) {
+
+        console.log(`update ${name} remark:`, remark)
+
+        this.curr.struct.extra[name].remark = remark
+    }
+}
+
+const commentRemark = (remark = '') => remark.replace(/\n/g, '\n\t * ')
+
+function submit() {
+
+    this.curr.updateStruct(this.curr.struct)
+    this.curr.updateRecord(this.curr.record)
+
+    this.prev.close()
+    this.curr.close()
+
+    clipTypeTs(this.typePath, this.curr.struct)
+    clipIndexMjs(this.currPath, this.curr.struct)
+
+    const version = readdirSync(this.dir).map(v => parseFloat(v) || 0).sort(sort).pop()
+
+    writeFileSync(`${this.dir}index.mjs`, `
+const index = import.meta.url.indexOf('?')
+
+const url = \`./${version}/index.mjs\${index > -1 ? import.meta.url.substring(index) : ''}\`
+
+/**
+ * @type {import('./${version}/type').Storage}
+ */
+const storage = await new Promise((resolve, reject) => import(url)
+    .then(modules => resolve(modules.default)).catch(error => reject(error)))
+
+export default storage
+`)
+
+    if (this.updateSet.size) {
+
+        return Promise.all([import(this.prevPath + this.prevUrlParams), import(this.currPath + this.currUrlParams)])
+            .then(([prev, curr]) => {
+
+                prev = prev.default
+                curr = curr.default
+
+                for (const name of this.updateSet.values()) {
+
+                    curr[name].remove(...curr[name])
+
+                    this.curr.record.idle[name] = []
+
+                    curr[name].push(...prev[name])
+                }
+
+                prev.close()
+                curr.close()
+            })
+
+    } else {
+
+        return Promise.resolve()
+    }
+}
+
+const initDir = (name, dir) => {
+
+    const existsDir = existsSync(name) && statSync(name).isDirectory()
+
+    if (!existsDir) {
+
+        mkdirSync(name)
+    }
+
+    if (!existsSync(dir)) {
+
+        mkdirSync(dir)
+    }
+
+    const indexMjsPath = dir + '/index.mjs'
+    const indexPath = dir + '/index'
+    const dataPath = dir + '/data'
+    const bufPath = dir + '/buffer'
+
+    if (!existsSync(indexMjsPath)) {
+
+        writeFileSync(indexMjsPath, `
+import {Storage, Store} from '${modulePath}'
+import {struct} from '${modulePath2}'
+
+const storage = new Storage(import.meta.url)
+
+export const remark = Symbol('remark')
+
+export function getStruct() {
+
+    return struct(storage, remark)
+}
+
+export default new class extends Store {
+
+    close() {
+        storage.close()
+    }
+}`)
+    }
+
+    if (!existsSync(indexPath)) {
+
+        writeFileSync(indexPath, buffer.alloc(0))
+    }
+
+    if (!existsSync(dataPath)) {
+
+        writeFileSync(dataPath, buffer.alloc(0))
+    }
+
+    if (!existsSync(bufPath)) {
+
+        mkdirSync(bufPath)
+    }
+
+    return new Storage(dir + '/')
+}
+
+const copyDir = (src, dest) => {
+
+    mkdirSync(dest)
+
+    for (const name of readdirSync(src)) {
+
+        const srcPath = `${src}/${name}`
+        const destPath = `${dest}/${name}`
+
+        if (statSync(srcPath).isDirectory()) {
+
+            copyDir(srcPath, destPath)
+
+        } else {
+
+            copyFileSync(srcPath, destPath)
+        }
+    }
+}
+
+const gen = {
+    get: [
+        code => code + '.readUInt32BE(0)',
+        (code, size) => {
+            switch (size) {
+                case 1:
+                    return code + '.readUint8(0)'
+                case 2:
+                    return code + '.readUint16BE(0)'
+                case 3:
+                    return `readUint24BE(${code})`
+                case 4:
+                    return code + '.readUInt32BE(0)'
+            }
+            return code
+        },
+        (code, size) => {
+            switch (size) {
+                case 1:
+                    return code + '.readInt8(0)'
+                case 2:
+                    return code + '.readInt16BE(0)'
+                case 3:
+                    return `readInt24BE(${code})`
+                case 4:
+                    return code + '.readInt32BE(0)'
+            }
+            return code
+        },
+        code => code + '.readBigUInt64BE(0)',
+        code => code + '.readBigInt64BE(0)',
+        code => `b2d(${code})`,
+        code => code + '.readDoubleBE(0)',
+        code => `b2s(${code})`,
+        (code, length) => `${code}[0] ? super.readFileSync(${length}) : null`,
+        (code, length) => `${code}[0] ? super.readFileSync(${length}).toString() : ''`,
+    ],
+    set: [
+        'uInt32BEToBuffer',
+        'super.uintToBuffer',
+        'super.intToBuffer',
+        'bigUint32BEToBuffer',
+        'bigint32BEToBuffer',
+        'd2b',
+        'doubleBEToBuffer',
+        'super.s2b',
+        'super.buffer',
+        'super.textToBuffer',
+    ],
+    type: [
+        'Number',
+        'Number',
+        'Number',
+        'Number | BigInt',
+        'Number | BigInt',
+        'Number | Date',
+        'Number',
+        'String',
+        'Buffer',
+        'String',
+    ]
+}
+
+const clipStatic = (name, [key, value]) => {
+
+    if (!Reflect.has(value, 'value')) return `\t\t\t${key},`
+
+    let valueStr = ''
+
+    if (Reflect.has(value, 'step')) return `\t\t\t${key}: storage.updateValue(${key}, ${name}.name, $${key}),`
+
+    switch (value.type) {
+
+        case typeMap.string:
+
+            valueStr = ` || '${value.value}'`
+
+            break
+
+        case typeMap.time:
+
+            if (value.value === TimeAttr.now || value.value === TimeAttr.update) {
+
+                valueStr = ` || new Date()`
+
+            } else if (typeof value.value === "string") {
+
+                valueStr = ` || new Date('${value.value}')`
+
+            } else {
+
+                valueStr = ' || ' + value.value
+            }
+
+            break
+
+        default:
+
+            valueStr = ' || ' + value.value
+    }
+
+    return `\t\t\t${key}${valueStr ? `: ${key}${valueStr}` : ''},`
+}
+
+const clipIndex = (name, key, k, v) => {
+
+    let main = '0'
+
+    if (v.type === typeMap.int) {
+
+        main = `super.intToBuffer(${k}, $${k})`
+
+    } else if (v.type === typeMap.uint) {
+
+        main = `super.uintToBuffer(${k}, $${k})`
+
+    } else {
+
+        main = `${gen.set[v.type]}(${k}${v.type === typeMap.buffer
+        || v.type === typeMap.text ? `, $${k}` : v.type === typeMap.string
+            ? `, $${k}` : ''})`
+    }
+
+    if (v.index) {
+
+        return `super.set2($${k}, ${main})`
+
+    } else {
+
+        return `super.set($${k}, ${main})`
+    }
+}
+
+const clipConst = struct => Array.from(new Set(Object.values(struct)
+    .map(struct => Object.keys(struct)).flat()))
+    .map(key => `const $${key} = '${key}'`)
+    .join('\n')
+
+const clipProperties = (name, key, update, [k, v]) => `
+            ${k}: {
+                enumerable: true,
+                configurable: false,
+                get: () => ${gen.get[v.type](`super.get($${k})`, v.type === typeMap.buffer
+|| v.type === typeMap.text ? `$${k}` : v.length)},
+                set: ${k} => ${update && k !== update[0] ? `{
+                    ${clipIndex(name, key, k, v)}
+                    this.#update()
+                }` : clipIndex(name, key, k, v)},
+            },`
+
+const sort = (a, b) => a - b
+
+const sort2 = (a, b) => a > b ? 1 : a < b ? -1 : 0
+
+const sort3 = ([a], [b]) => a > b ? 1 : a < b ? -1 : 0
+
+const clipEntity = ([key, value]) => {
+
+    const update = Object.entries(value).find(([_, v]) => v.type === typeMap.time && v.value === TimeAttr.update)
+
+    const name = key[0].toUpperCase() + key.substring(1)
+
+    return `
+class ${name} extends Entity {
+
+    static name = '${key}'
+    
+    static create({
+            ${Object.keys(value).sort(sort2).join(',\n\t\t\t')}
+        }) {
+    
+        return {
+${Object.entries(value).sort(sort3).map(clipStatic.bind(null, name)).join('\n')}
+        }
+    }
+
+    constructor(...arg) {
+
+        super(storage, ...arg)
+        
+        return Object.defineProperties({}, {
+            [position]: {
+                enumerable: false,
+                configurable: false,
+                get: () => this[position],
+            },${Object.entries(value).sort(sort3).map(clipProperties.bind(null, name, key, update)).join('')}
+        })
+    }
+${update ? `
+
+    #update() {
+
+        this.${update[0]} = Date.now()
+    }` : ''}
+}
+`
+}
+
+const clipEntities = ([key, value]) => {
+
+    const name = key[0].toUpperCase() + key.substring(1)
+
+    return `
+class ${name}Set extends Entities {
+
+    constructor() {
+
+        super(storage, ${name})
+    }
+    /**
+     * 内部方法
+     */
+    s2b() {
+
+        throw new TypeError('s2b is not a function')
+    }
+    /**
+     * 内部方法
+     */
+    findByValue() {
+
+        throw new TypeError('findByValue is not a function')
+    }
+    /**
+     * 内部方法
+     */
+    findByTime() {
+
+        throw new TypeError('findByTime is not a function')
+    }
+    /**
+     * 内部方法
+     */
+    stringToBuffer() {
+        
+        throw new TypeError('stringToBuffer is not a function')
+    }
+${Object.entries(value).map(([k, v]) => {
+
+        const n = k[0].toUpperCase() + k.substring(1)
+
+        if (v.index) {
+
+            if (v.type === typeMap.time) {
+
+                return `
+    indexBy${n}({after, before} = {}) {
+
+        return super.findByTime($${k}, {after, before})
+    }`
+
+            } else {
+
+                return `
+    indexBy${n}(${k}) {
+
+        return super.findByValue($${k}, ${gen.set[v.type]}(${k}, $${k}))
+    }`
+            }
+
+        } else {
+
+            return ''
+        }
+
+    }).filter(lines => lines.length).join('\n')}
+}
+`
+}
+
+const clipTypeTs = (path, struct) => writeFileSync(path, `${Object.entries(struct.base).map(([key, value]) => {
+        key = key[0].toUpperCase() + key.substring(1)
+
+        return `
+interface ${key} {
+    ${Object.entries(value).map(([key, value]) => `
+    /**
+     * ${commentRemark(value.remark)}
+     */
+    ${key}: ${gen.type[value.type]}`).join('')}
+}
+
+interface ${key}Set extends Array<${key}> {
+    ${Object.entries(value).filter(([, value]) => value.index).map(([k, value]) => {
+            const Key = k[0].toUpperCase() + k.substring(1)
+            return value.type === typeMap.time ? `
+    indexBy${Key}({after, before}): Array<${key}>` : `
+    indexBy${Key}(${k}: ${gen.type[value.type]}): Array<${key}>`
+        }).join('')}
+    /**
+     * 分页查询
+     */
+    page(predicate: Function, index: Number | String, size: Number | String, params: Object): Array<${key}>
+    /**
+     * 移除数据
+     */
+    remove(...items: Array<${key}>): void
+    /**
+     * 联合查询，类似LEFT JOIN
+     */
+    eachFlat(array: Array<Object>, predicate: Function | String): Array<Object>
+    /**
+     * 联合查询，类似INNER JOIN
+     */
+    filterFlat(array: Array<Object>, predicate: Function | String): Array<Object>
+}
+`
+    }
+).join('')}
+
+export interface Storage {
+    close(): void${Object.keys(struct.base).map(key => {
+    const Key = key[0].toUpperCase() + key.substring(1)
+    return `
+    ${key}: ${Key}Set`
+})}
+}
+`)
+
+const clipIndexMjs = (path, struct) => writeFileSync(path, `
+import {Entities, Entity, Storage, b2d, d2b, b2s, position, uInt32BEToBuffer, int32BEToBuffer,
+doubleBEToBuffer, bigint32BEToBuffer, bigUint32BEToBuffer, readInt24BE, readUint24BE, Store} from '${modulePath}'
+import {struct} from '${modulePath2}'
+
+const storage = new Storage(import.meta.url)
+
+${clipConst(struct.base)}
+${Object.entries(struct.base).map(clipEntity).join('')}
+${Object.entries(struct.base).map(clipEntities).join('')}
+export const remark = Symbol('remark')
+
+export function getStruct() {
+
+    return struct(storage, remark)
+}
+
+/**
+ * @type {import('./type').Storage}
+ */
+const store = Object.freeze({
+    close() {
+        storage.close()
+    },${Object.keys(struct.base).map(key => {
+    const Key = key[0].toUpperCase() + key.substring(1)
+    return `
+    ${key}: new Proxy([], {
+        get: new ${Key}Set()
+    }),`
+}).join('')}
+})
+
+export default store
+`)
+
+/**
+ * 升级
+ * @param {string} name
+ * @param {string} newPwd
+ * @param {string} password
+ * @param {number} version
+ * @return {import('./type').Gen}
+ * @example
+ * const {submit} = upgrade('test')
+ * submit()
+ */
+export default function upgrade(name, {
+    newPwd,
+    password = '',
+    version = 1,
+} = {}) {
+
+    const dir = name[name.length - 1] === '/' ? name : name + '/'
+
+    if (!existsSync(dir)) {
+
+        mkdirSync(dir)
+    }
+
+    let v = readdirSync(dir).map(v => parseFloat(v) || 0).sort(sort).pop()
+
+    let prev
+
+    if (v === undefined) {
+
+        v = 0
+
+        prev = initDir(name, dir + 0)
+
+        prev.init()
+
+    } else {
+
+        prev = new Storage(dir + v + '/', password)
+    }
+
+    if (version <= v) {
+
+        version = v + 1
+    }
+
+    console.log(`version: ${v} -> ${version}`)
+
+    copyDir(dir + v, dir + version)
+
+    const curr = new Storage(dir + version + '/', password, newPwd)
+    const root = resolve('/')
+    const rootDir = (root.length > 1 ? resolve('./').substring(root.length - 1) : resolve('./'))
+        .replace(/\\/g, '/')
+    const prevUrlParams = `?t=${Date.now()}${password ? `&password=${password}` : ''}`
+    const currUrlParams = newPwd ? `${prevUrlParams}&password=${newPwd}` : prevUrlParams
+
+    const scope = {
+        dir: `${rootDir}/${dir}`,
+        prevUrlParams,
+        currUrlParams,
+        prevPath: `${rootDir}/${dir}${v}/index.mjs`,
+        currPath: `${rootDir}/${dir}${version}/index.mjs`,
+        typePath: `${rootDir}/${dir}${version}/type.ts`,
+        prev,
+        curr,
+        types: [Id, Uint, Int, BigUint, Bigint, Time, Float, String, Buffer, Text],
+        updateSet: new Set,
+    }
+
+    return {
+        /**
+         * 添加集合
+         * @type {function}
+         * @param {string} name
+         * @param {Object} set
+         * @param {string} remark
+         * @example
+         * appendSet(name, set, remark)
+         */
+        appendSet: appendSet.bind(scope),
+        /**
+         * 更新集合
+         * @type {function}
+         * @param {string} name
+         * @param {Object} set
+         * @example
+         * updateCol(name, set)
+         */
+        updateCol: updateCol.bind(scope),
+        /**
+         * 集合改名
+         * @type {function}
+         * @param {string} name
+         * @param {string} newName
+         * @example
+         * renameSet(name, newName)
+         */
+        renameSet: renameSet.bind(scope),
+        /**
+         * 改键名
+         * @type {function}
+         * @param {string} name
+         * @param {Object} set
+         * @example
+         * renameCol(name, set)
+         */
+        renameCol: renameCol.bind(scope),
+        /**
+         * 删除集合
+         * @type {function}
+         * @param {string} name
+         * @example
+         * deleteSet(name)
+         */
+        deleteSet: deleteSet.bind(scope),
+        /**
+         * 删除集合
+         * @type {function}
+         * @param {string} name
+         * @param {string} colName
+         * @example
+         * deleteCol(name, colName)
+         */
+        deleteCol: deleteCol.bind(scope),
+        /**
+         * 更新集合备注
+         * @type {function}
+         * @param {string} name
+         * @param {string} remark
+         * @example
+         * updateSetRemark(name, remark)
+         */
+        updateSetRemark: updateSetRemark.bind(scope),
+        /**
+         * 提交跟新
+         * @type {function}
+         */
+        submit: submit.bind(scope),
+    }
+}