@backtest/framework
Version:
Backtesting trading strategies in TypeScript / JavaScript
164 lines • 6.78 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.importCSV = importCSV;
exports.exportCSV = exportCSV;
const parse_1 = require("../helpers/parse");
const prisma_historical_data_1 = require("./prisma-historical-data");
const error_1 = require("./error");
const logger = __importStar(require("./logger"));
const csvtojson_1 = __importDefault(require("csvtojson"));
const path = __importStar(require("path"));
const fs = __importStar(require("fs"));
function _getNormalizedField(json, possibleFields) {
const normalizedFields = Object.keys(json).reduce((acc, key) => {
acc[key.toLowerCase()] = key;
return acc;
}, {});
for (const field of possibleFields) {
if (normalizedFields[field.toLowerCase()]) {
return normalizedFields[field.toLowerCase()];
}
}
return null;
}
function _getFieldKeys(json, fields) {
const fieldKeys = {};
for (const [key, possibleFields] of Object.entries(fields)) {
const fieldKey = _getNormalizedField(json, possibleFields);
if (fieldKey) {
fieldKeys[key] = fieldKey;
}
else {
throw new error_1.BacktestError(`CSV does not have a valid ${possibleFields.join(', ')} field`, error_1.ErrorCode.InvalidInput);
}
}
return fieldKeys;
}
function _getOptionalFieldKeys(json, fields) {
const optionalFields = {};
for (const [key, possibleFields] of Object.entries(fields)) {
const fieldKey = _getNormalizedField(json, possibleFields);
if (fieldKey) {
optionalFields[key] = fieldKey;
}
}
return optionalFields;
}
async function importCSV(importCSVParams) {
let jsonCSV;
try {
jsonCSV = await (0, csvtojson_1.default)().fromFile(importCSVParams.path);
}
catch (error) {
throw new error_1.BacktestError(`Path ${importCSVParams.path} does not exist or is incorrect`, error_1.ErrorCode.InvalidPath);
}
const json = jsonCSV[0];
const requiredFields = {
closeTime: ['closeTime', 'date'],
open: ['open'],
close: ['close'],
low: ['low'],
high: ['high']
};
const optionalFields = {
openTime: ['openTime'],
volume: ['volume'],
assetVolume: ['assetVolume'],
numberOfTrades: ['numberOfTrades']
};
try {
const fieldKeys = _getFieldKeys(json, requiredFields);
const optionalFileds = _getOptionalFieldKeys(json, optionalFields);
const jsonParsedCandles = jsonCSV.map((entry) => ({
openTime: optionalFileds.openTime ? new Date(+entry[optionalFileds.openTime]).getTime() : 0,
open: +entry[fieldKeys.open],
high: +entry[fieldKeys.high],
low: +entry[fieldKeys.low],
close: +entry[fieldKeys.close],
volume: optionalFileds.volume ? +entry[optionalFileds.volume] : 0,
closeTime: new Date(+entry[fieldKeys.closeTime]).getTime(),
assetVolume: optionalFileds.assetVolume ? +entry[optionalFileds.assetVolume] : 0,
numberOfTrades: optionalFileds.numberOfTrades ? +entry[optionalFileds.numberOfTrades] : 0
}));
const meta = {
name: `${importCSVParams.base + importCSVParams.quote}-${importCSVParams.interval}`,
symbol: importCSVParams.base + importCSVParams.quote,
interval: importCSVParams.interval,
base: importCSVParams.base,
quote: importCSVParams.quote,
startTime: jsonParsedCandles[0].closeTime,
endTime: jsonParsedCandles[jsonParsedCandles.length - 1].closeTime,
importedFromCSV: true,
creationTime: new Date().getTime(),
lastUpdatedTime: new Date().getTime()
};
const insertedCandles = await (0, prisma_historical_data_1.insertCandles)(meta, jsonParsedCandles);
logger.info(`Successfully imported ${importCSVParams.base + importCSVParams.quote} from ${(0, parse_1.dateToString)(meta.startTime)} to ${(0, parse_1.dateToString)(meta.endTime)}`);
return true;
}
catch (error) {
throw new error_1.BacktestError((error === null || error === void 0 ? void 0 : error.message) || 'Generic error !?', error_1.ErrorCode.ActionFailed);
}
}
async function exportCSV(name, rootPath = './csv') {
const candles = await (0, prisma_historical_data_1.getCandles)(name);
if (!candles) {
throw new error_1.BacktestError(`No candles found for name ${name}`, error_1.ErrorCode.NotFound);
}
const keys = Object.keys(candles.candles[0]);
const headerRow = keys.join(',') + '\n';
const dataRows = candles.candles
.map((obj) => {
const values = keys.map((key) => {
const value = obj[key];
return typeof value === 'string' ? `"${value}"` : value;
});
return values.join(',');
})
.join('\n');
const dir = rootPath || './csv';
if (!fs.existsSync(dir)) {
fs.mkdirSync(dir);
}
const filePath = path.join(dir, `${name}.csv`);
fs.writeFileSync(filePath, headerRow + dataRows);
logger.info(`Successfully exported data to ./csv folder with name ${name}.csv`);
return true;
}
//# sourceMappingURL=csv.js.map