初始化项目

15815213711

2024-08-26 67b8b6731811983447e053d4396b3708c14dfe3c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
'use strict';
 
const assert = require('assert');
const fs = require('fs');
const path = require('path');
const Database = require('better-sqlite3');
const Helper = require('../utils/helper');
const Ps = require('../ps');
 
class SqliteStorage {
  constructor (name, opt = {}) {
    assert(name, `db name ${name} Cannot be empty`);
 
    this.name = name;
    this.mode = this.getMode(name);
    this.storageDir = this._createStorageDir();
    this.fileName = this._formatFileName(name);
    this.db = this._initDB(opt);
  }
 
  /**
   * 初始化db
   */
  _initDB (opt = {}) {
    let options = Object.assign({
      timeout: 5000,
    }, opt);
 
    // 存储类型：db文件、内存(:memory:)
    let dbPath = this.name;
    if (this.mode != 'memory') {
      dbPath = this.getFilePath();
    }
 
    const db = new Database(dbPath, options);
 
    // 如果是文件类型，判断文件是否创建成功
    if (this.mode != 'memory') {
      assert(fs.existsSync(dbPath), `error: storage ${dbPath} not exists`);
    }
 
    return db;
  }
 
  /**
   * 获取文件名
   */
  _formatFileName (name) {
    let fileName = name;
    if (this.mode != 'memory') {
      fileName = path.basename(name);
    }
 
    return fileName;
  }
 
  /**
   * 创建storage目录
   */
  _createStorageDir () {
    let storageDir = Ps.getStorageDir();
 
    if (this.mode == 'absolute') {
      storageDir = path.dirname(this.name); 
    }
 
    if (!fs.existsSync(storageDir)) {
      Helper.mkdir(storageDir);
      Helper.chmodPath(storageDir, '777');
    }
 
    return storageDir;
  }
 
  /**
   * 获取file path 模式
   */
  getMode (name) {
    let mode = '';
 
    // 内存模式
    if (name == ':memory:') {
      mode = 'memory';
      return mode;
    }
 
    assert(path.extname(name) == '.db', `error: storage ${name} file ext name must be .db`);
 
    // 路径模式
    name = name.replace(/[/\\]/g, '/');
    if (name.indexOf('/') !== -1) {
      const isAbsolute = path.isAbsolute(name);
      if (isAbsolute) {
        mode = 'absolute';
      } else {
        mode = 'relative';
      }
      return mode;
    }
 
    // 仅文件名
    mode = 'onlyName';
 
    return mode;
  }
 
  /**
   * 获取storage目录
   */
  getStorageDir () {
    return this.storageDir;
  }
 
  /**
   * 获取文件绝对路径
   */
  getFilePath () {
    const dbFile = path.join(this.storageDir, this.fileName);
 
    return dbFile;
  }
}
 
module.exports = SqliteStorage;