@sidekick-coder/db
Version:
Cli Tool to manipulate data from diferent sources
466 lines (455 loc) • 13 kB
JavaScript
;
var fs = require('fs');
var valibot = require('valibot');
var path = require('path');
var url = require('url');
var yaml = require('yaml');
var qs = require('qs');
var inquirer = require('@inquirer/prompts');
var lodashEs = require('lodash-es');
var fg = require('fast-glob');
var minimist = require('minimist');
function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
function _interopNamespace(e) {
if (e && e.__esModule) return e;
var n = Object.create(null);
if (e) {
Object.keys(e).forEach(function (k) {
if (k !== 'default') {
var d = Object.getOwnPropertyDescriptor(e, k);
Object.defineProperty(n, k, d.get ? d : {
enumerable: true,
get: function () { return e[k]; }
});
}
});
}
n.default = e;
return Object.freeze(n);
}
var fs__default = /*#__PURE__*/_interopDefault(fs);
var valibot__namespace = /*#__PURE__*/_interopNamespace(valibot);
var path__default = /*#__PURE__*/_interopDefault(path);
var qs__default = /*#__PURE__*/_interopDefault(qs);
var inquirer__namespace = /*#__PURE__*/_interopNamespace(inquirer);
var fg__default = /*#__PURE__*/_interopDefault(fg);
var minimist__default = /*#__PURE__*/_interopDefault(minimist);
// src/utils/vars.ts
// src/utils/tryCatch.ts
async function tryCatch(tryer) {
try {
const result = await tryer();
return [result, null];
} catch (error) {
return [null, error];
}
}
tryCatch.sync = function(tryer) {
try {
const result = tryer();
return [result, null];
} catch (error) {
return [null, error];
}
};
var parse = yaml.parse;
var stringify = yaml.stringify;
var YAML = {
parse,
stringify
};
function readFileSync(path4) {
const [content, error] = tryCatch.sync(() => fs__default.default.readFileSync(path4));
if (error) {
return null;
}
return new Uint8Array(content);
}
readFileSync.text = function(filepath, defaultValue = "") {
const content = readFileSync(filepath);
if (!content) {
return defaultValue;
}
return new TextDecoder().decode(content);
};
readFileSync.json = function(path4, options) {
const content = readFileSync.text(path4);
if (!content) {
return (options == null ? void 0 : options.default) || null;
}
const [json, error] = tryCatch.sync(() => JSON.parse(content, options == null ? void 0 : options.reviver));
return error ? (options == null ? void 0 : options.default) || null : json;
};
readFileSync.yaml = function(path4, options) {
const content = readFileSync.text(path4);
if (!content) {
return (options == null ? void 0 : options.default) || null;
}
const [yml, error] = tryCatch.sync(() => YAML.parse(content, options == null ? void 0 : options.parseOptions));
return error ? (options == null ? void 0 : options.default) || null : yml;
};
var filesystem = {
readSync: readFileSync};
function createReviver(folder) {
return (_, value) => {
if (typeof value == "string" && value.startsWith("./")) {
return path.resolve(path.dirname(folder), value);
}
return value;
};
}
var schema = valibot__namespace.optional(
valibot__namespace.pipe(
valibot__namespace.any(),
valibot__namespace.transform((value) => {
if (typeof value == "object") {
return value;
}
if (/\.yml$/.test(value)) {
const file = value.replace(/^@/, "");
const folder = path.dirname(file);
return filesystem.readSync.yaml(value.replace(/^@/, ""), {
reviver: createReviver(folder)
});
}
if (typeof value == "string" && value.includes("=")) {
const result = qs__default.default.parse(value, { allowEmptyArrays: true });
return result;
}
if (typeof value == "string" && value.startsWith("{")) {
return JSON.parse(value);
}
if (typeof value == "string" && value.startsWith("[")) {
return JSON.parse(value);
}
return value;
}),
valibot__namespace.record(valibot__namespace.string(), valibot__namespace.any())
)
);
function createPathNode() {
return {
resolve: (...args) => path__default.default.resolve(...args),
join: (...args) => path__default.default.join(...args),
dirname: (args) => path__default.default.dirname(args),
basename: (args) => path__default.default.basename(args)
};
}
// src/core/validator/valibot.ts
var stringList = valibot__namespace.pipe(
valibot__namespace.any(),
valibot__namespace.transform((value) => {
if (typeof value === "string") {
return value.split(",");
}
if (Array.isArray(value)) {
return value;
}
}),
valibot__namespace.array(valibot__namespace.string())
);
function array2(s) {
return valibot__namespace.pipe(
v2.union([v2.array(s), s]),
valibot__namespace.transform((value) => Array.isArray(value) ? value : [value]),
valibot__namespace.array(s)
);
}
function path3(dirname2, path4 = createPathNode()) {
return valibot__namespace.pipe(
valibot__namespace.string(),
valibot__namespace.transform((value) => path4.resolve(dirname2, value))
);
}
function uint8() {
return valibot__namespace.pipe(
valibot__namespace.any(),
valibot__namespace.check((value) => value instanceof Uint8Array),
valibot__namespace.transform((value) => value)
);
}
var prompts = {
password: (options) => valibot__namespace.optionalAsync(valibot__namespace.string(), () => {
return inquirer__namespace.password({
message: "Enter password",
...options
});
})
};
var extras = {
array: array2,
vars: schema,
stringList,
path: path3,
uint8,
number: valibot__namespace.pipe(
valibot__namespace.any(),
valibot__namespace.transform(Number),
valibot__namespace.check((n) => !isNaN(n)),
valibot__namespace.number()
)
};
var vWithExtras = {
...valibot__namespace,
extras,
prompts
};
var v2 = vWithExtras;
// src/core/validator/validate.ts
function validate(cb, payload) {
const schema3 = typeof cb === "function" ? cb(v2) : cb;
const { output, issues, success } = v2.safeParse(schema3, payload);
if (!success) {
const flatten = v2.flatten(issues);
const messages = [];
if (flatten.root) {
messages.push(...flatten.root);
}
if (flatten.nested) {
Object.entries(flatten.nested).forEach((entry) => {
const [key, value] = entry;
messages.push(...value.map((v3) => `${key}: ${v3}`));
});
}
const message = messages.length ? messages.join(", ") : "Validation failed";
const error = new Error(message);
error.name = "ValidationError";
Object.assign(error, {
messages
});
throw error;
}
return output;
}
validate.async = async function(cb, payload) {
let schema3;
if (typeof cb === "function") {
schema3 = cb(v2);
} else {
schema3 = cb;
}
const { output, issues, success } = await v2.safeParseAsync(schema3, payload);
if (!success) {
const error = new Error("Validation failed");
const flatten = v2.flatten(issues);
const details = {
...flatten.root,
...flatten.nested
};
Object.assign(error, {
details
});
throw error;
}
return output;
};
// src/core/database/where.ts
function parseCondition(condition) {
if (condition.value === "$true") {
return {
or: [],
and: [
{
field: condition.field,
operator: condition.operator,
value: true
}
]
};
}
if (condition.value === "$false") {
return {
or: [],
and: [
{
field: condition.field,
operator: condition.operator,
value: false
}
]
};
}
if (condition.value === "$exists") {
return {
or: [],
and: [
{
field: condition.field,
operator: "exists",
value: true
}
]
};
}
if (typeof condition.value == "string" && condition.value.startsWith("$in")) {
const values = condition.value.slice(4, -1).split(",");
return {
or: [],
and: [
{
field: condition.field,
operator: "in",
value: values
}
]
};
}
return {
and: [condition],
or: []
};
}
function transformWhere(where) {
const { and, or, ...rest } = where;
const result = {
and: [],
or: []
};
if ((rest == null ? void 0 : rest.field) && (rest == null ? void 0 : rest.operator)) {
return {
field: rest.field,
operator: rest.operator,
value: rest.value
};
}
for (const [key, value] of Object.entries(rest)) {
const { and: and2, or: or2 } = parseCondition({
field: (value == null ? void 0 : value.field) || key,
operator: (value == null ? void 0 : value.operator) || "eq",
value: (value == null ? void 0 : value.value) || value
});
if (and2) {
result.and.push(...and2);
}
if (or2) {
result.or.push(...or2);
}
}
if (and == null ? void 0 : and.length) {
and.forEach((w) => {
result.and.push(transformWhere(w));
});
}
if (or == null ? void 0 : or.length) {
or.forEach((w) => {
result.or.push(transformWhere(w));
});
}
if (!result.or.length) {
delete result.or;
}
if (!result.and.length) {
delete result.and;
}
return result;
}
var schema2 = v2.pipe(v2.any(), v2.transform(transformWhere));
function parseFile(filename) {
const extensions = [".yml", ".yaml", ".json"];
if (extensions.some((ext) => filename.endsWith(`*${ext}`))) {
const pattern = fg__default.default.convertPathToPattern(filename);
const files = fg__default.default.sync(pattern);
return files.map((file) => parseFile(file));
}
const contents = fs__default.default.readFileSync(filename, "utf-8");
const reviver = (key, value) => {
if (typeof value == "string" && extensions.some((ext) => value.endsWith(ext))) {
return parseFile(value);
}
return value;
};
if (filename.endsWith(".json")) {
return JSON.parse(contents, reviver);
}
if (filename.endsWith(".yml") || filename.endsWith(".yaml")) {
return YAML.parse(contents, reviver);
}
return contents;
}
function parseVars(payload) {
const items = Array.isArray(payload) ? payload : [payload];
if (!items.length) {
return {};
}
let result = {};
items.forEach((item) => {
const vars = validate((v3) => v3.extras.vars, item);
result = lodashEs.mergeWith(result, vars, (objValue, srcValue) => {
if (Array.isArray(objValue)) {
return objValue.concat(srcValue);
}
});
});
return result;
}
function parseWhere(payload) {
const record2 = parseVars(payload);
return validate(() => schema2, record2);
}
var parse2 = yaml.parse;
var stringify2 = yaml.stringify;
var QS = {
parse: qs.parse,
stringify: qs.stringify
};
async function importAll(path4, options) {
const files = await fs.promises.readdir(path4);
const result = {};
for await (const file of files) {
if ((options == null ? void 0 : options.exclude) && options.exclude.includes(file)) {
continue;
}
const url$1 = url.pathToFileURL(path.resolve(path4, file));
const module = await import(url$1.href);
result[file] = module;
}
return result;
}
function parseOptions(args, options) {
var _a, _b, _c;
const flags = minimist__default.default(args, {
string: ["where", "view", "data", "render", "id"],
alias: {
where: "w",
view: "v",
data: "d",
render: "r",
render_options: "ro",
sortBy: ["sort-by"],
sortDesc: ["sort-desc"]
}
});
const result = validate(
(v3) => {
var _a2, _b2;
return v3.objectWithRest(
{
view: v3.optional(v3.string(), (_b2 = (_a2 = options == null ? void 0 : options.databaseDefinition) == null ? void 0 : _a2.view) == null ? void 0 : _b2.default),
render: v3.optional(v3.string()),
data: v3.optional(v3.extras.vars),
where: v3.optional(v3.extras.vars),
include: v3.optional(v3.extras.stringList),
exclude: v3.optional(v3.extras.stringList),
render_options: v3.optional(v3.extras.vars, {}),
sortBy: v3.optional(v3.extras.stringList),
sortDesc: v3.optional(v3.extras.array(v3.boolean()))
},
v3.any()
);
},
flags
);
if (result.view && (options == null ? void 0 : options.databaseDefinition)) {
const view = (_c = (_b = (_a = options.databaseDefinition) == null ? void 0 : _a.view) == null ? void 0 : _b.sources) == null ? void 0 : _c.find((v3) => v3.name === result.view);
lodashEs.merge(result, lodashEs.omit(view, "name"));
}
return result;
}
exports.QS = QS;
exports.importAll = importAll;
exports.parse = parse2;
exports.parseFile = parseFile;
exports.parseOptions = parseOptions;
exports.parseVars = parseVars;
exports.parseWhere = parseWhere;
exports.stringify = stringify2;