TypeScript levelup.LevelUp類代碼示例

  public async buildExistingFilesDb(watchPath: string): Promise<number> {
    try {
      const cwd = watchPath;

      const files = await globPromise(`**/*`, {
        cwd
      });

      const filePayload: FilePayload = {
        jobStatus: FileJobStatus.Existing,
        jobType: FileJobType.Unknown
      };

      const existingFiles = files.map(
        (filepath: string): AbstractBatch => ({
          key: path.resolve(cwd, filepath),
          type: 'put',
          value: filePayload
        })
      );

      await this.files.batch(existingFiles);

      return existingFiles.length;
    } catch (error) {
      throw error;
    }
  }

 async addKeys(params: {
   name: string;
   keys: Wallet.KeyImport[];
   encryptionKey: string;
 }) {
   const { name, keys, encryptionKey } = params;
   const ops = keys.map(key => {
     let { pubKey } = key;
     pubKey =
       pubKey || new bitcoreLib.PrivateKey(key.privKey).publicKey.toString();
     let payload = {};
     if (pubKey && key.privKey && encryptionKey) {
       const encKey = Encryption.encryptPrivateKey(
         JSON.stringify(key),
         Buffer.from(pubKey, 'hex'),
         Buffer.from(encryptionKey, 'hex')
       );
       payload = { encKey, pubKey };
     }
     return {
       type: 'put',
       key: `key|${name}|${key.address}`,
       value: JSON.stringify(payload)
     };
   });
   if (ops.length > 1) {
     return this.db.batch(ops);
   } else {
     this.db.put(ops[0].key, ops[0].value);
   }
 }

  public get(query: any, callback: (data: any) => void) {
    if (query === null) {
      const result: any = {};

      this.db
        .createReadStream()
        .on('data', (data: any) => {
          result[data.key] = data.value;
        })
        .on('end', () => {
          callback(result);
        });
    } else if (Array.isArray(query)) {
      const result: any = {};

      this.db
        .createReadStream()
        .on('data', (data: any) => {
          for (const key of query) {
            if (key === data.key) {
              result[data.key] = data.value;
            }
          }
        })
        .on('end', () => {
          callback(result);
        });
    } else if (typeof query === 'object') {
      const result: any = { ...query };

      this.db
        .createReadStream()
        .on('data', (data: any) => {
          for (const key in query) {
            if (key === data.key && data.value !== undefined) {
              result[data.key] = data.value;
            }
          }
        })
        .on('end', () => {
          callback(result);
        });
    } else if (typeof query === 'string') {
      this.db.get(query, (err, value) => {
        if (err) {
          if (err.notFound) {
            return callback({});
          }
        }

        callback({ [query]: value });
      });
    } else {
      callback({});
    }
  }

  public async enqueueFile(
    filepath: string,
    filetype: FileJobType
  ): Promise<boolean> {
    try {
      const tag = new Tag(filepath);

      const jobType = filetype;
      const jobStatus = FileJobStatus.Pending;

      const filePayload: FilePayload = {
        jobStatus,
        jobType
      };

      await this.files.put(filepath, filePayload);

      const fileJobPayload: FileJobPayload = {
        filepath,
        jobType
      };

      const jobId = await this.queue.pushPromise(fileJobPayload);

      logger.debug('File enqueued with jobId: %s', jobId);

      await tag.addTag('Yellow');

      return true;
    } catch (err) {
      logger.error('Error in enqueue\n%s', prettyPrint(err));
      return false;
    }
  }

 async loadWallet(params: { name: string }) {
   const { name } = params;
   const wallet = (await this.db.get(`wallet|${name}`)) as string;
   if (!wallet) {
     return;
   }
   return JSON.parse(wallet);
 }

 this.get(null, data => {
   const batch = this.db.batch();
   for (const key in data) {
     batch.del(key);
   }
   batch.write(() => {
     callback();
   });
 });

  public remove(keys: any, callback: any) {
    if (typeof keys === 'string') {
      this.db.del(keys, err => {
        callback();
      });
    } else if (Array.isArray(keys)) {
      const batch = this.db.batch();

      for (const key of keys) {
        batch.del(key);
      }

      batch.write(() => {
        callback();
      });
    } else {
      // error
    }
  }

  public async handler(_: string, payload: any): Promise<void> {
    try {
      const { filepath, jobType } = payload;

      logger.info('Starting work for %s', filepath);

      const tag = new Tag(filepath);

      const currentValue = await this.files.get(filepath);
      const { jobStatus } = currentValue;

      logger.debug('Work type: %s', FileJobType[jobType]);

      try {
        const handled =
          jobStatus === FileJobStatus.Pending && existsSync(filepath)
            ? this.handleFile(filepath, jobType) && true
            : false;

        currentValue.jobStatus = handled
          ? FileJobStatus.Complete
          : FileJobStatus.Unhandled;

        await tag.removeTag('Red');
        await tag.removeTag('Yellow');
        await tag.addTag('Green');
      } catch (err) {
        logger.error(err);

        currentValue.jobStatus = FileJobStatus.Error;

        await tag.removeTag('Green');
        await tag.removeTag('Yellow');
        await tag.addTag('Red');
      } finally {
        this.files.put(filepath, currentValue);
      }
    } catch (err) {
      logger.error(err);
    }
  }

 public async isNewFile(filepath: string): Promise<boolean> {
   try {
     await this.files.get(filepath);
     return false;
   } catch (err) {
     switch (err.notFound) {
       case true:
         return true;
       default:
         throw err;
     }
   }
 }

 listWallets() {
   return this.db.createReadStream().pipe(
     new Transform({
       objectMode: true,
       write: function(data, enc, next) {
         if (data.key.toString().startsWith('wallet')) {
           this.push(data.value.toString());
         }
         next();
       }
     })
   );
 }