@sidekick-coder/db/dist/providers/file/__tests__/factories.cjs

Cli Tool to manipulate data from diferent sources

'use strict';

var valibot = require('valibot');
var path = require('path');
var fs = require('fs');
require('url');
var yaml = require('yaml');
var qs = require('qs');
require('@inquirer/prompts');

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 valibot__namespace = /*#__PURE__*/_interopNamespace(valibot);
var fs__default = /*#__PURE__*/_interopDefault(fs);
var qs__default = /*#__PURE__*/_interopDefault(qs);

// src/core/validator/valibot.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;
  };
}
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())
  )
);

// src/core/validator/valibot.ts
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())
);
({
  number: valibot__namespace.pipe(
    valibot__namespace.any(),
    valibot__namespace.transform(Number),
    valibot__namespace.check((n) => !isNaN(n)),
    valibot__namespace.number()
  )
});

// src/core/idStrategy/createIncremental.ts
function pad(value, size) {
  return value.toString().padStart(size, "0");
}

// src/providers/file/__tests__/factories.ts
function createFactories(options) {
  const { filesystem: filesystem2, parser, root } = options;
  const resolve3 = filesystem2.path.resolve;
  function makeItem(payload = {}) {
    const id = pad(filesystem2.readdirSync(root).length, 2);
    const filename = resolve3(root, `${id}.${parser.ext}`);
    const raw = parser.stringify(payload);
    filesystem2.writeSync.text(filename, raw);
    return {
      id,
      filename,
      raw,
      ...parser.parse(raw)
    };
  }
  function makeManyItems(count = 5, payload) {
    const items = [];
    for (let i = 0; i < count; i++) {
      items.push(makeItem(payload));
    }
    return items;
  }
  return {
    makeItem,
    makeManyItems
  };
}

exports.createFactories = createFactories;