@phalcode/ts-apicalypse/dist/index.js

A Typescript client and request builder for Apicalypse

// src/index.ts
import axios from "axios";

// src/types.ts
var WhereFlags = /* @__PURE__ */ ((WhereFlags2) => {
  WhereFlags2[WhereFlags2["RAW"] = 1] = "RAW";
  WhereFlags2[WhereFlags2["NUMBER"] = 1 /* RAW */] = "NUMBER";
  WhereFlags2[WhereFlags2["STRING"] = 2] = "STRING";
  WhereFlags2[WhereFlags2["STARTSWITH"] = 6] = "STARTSWITH";
  WhereFlags2[WhereFlags2["ENDSWITH"] = 10] = "ENDSWITH";
  WhereFlags2[WhereFlags2["CONTAINS"] = 14] = "CONTAINS";
  return WhereFlags2;
})(WhereFlags || {});
var WhereInFlags = /* @__PURE__ */ ((WhereInFlags2) => {
  WhereInFlags2[WhereInFlags2["AND"] = 32] = "AND";
  WhereInFlags2[WhereInFlags2["NAND"] = 48] = "NAND";
  WhereInFlags2[WhereInFlags2["OR"] = 64] = "OR";
  WhereInFlags2[WhereInFlags2["NOR"] = 80] = "NOR";
  WhereInFlags2[WhereInFlags2["EXACT"] = 128] = "EXACT";
  return WhereInFlags2;
})(WhereInFlags || {});

// src/builder.ts
function query(queryEndpoint, queryName) {
  return (builder) => {
    return {
      ...builder,
      queryEndpoint,
      queryName
    };
  };
}
function fields(f) {
  if (Array.isArray(f)) {
    const fieldsString = f.join(",").replace(/\s/g, "");
    return (builder) => {
      return {
        ...builder,
        queryFields: {
          ...builder.queryFields,
          fields: `fields ${fieldsString}`
        }
      };
    };
  }
  return (builder) => {
    return {
      ...builder,
      queryFields: {
        ...builder.queryFields,
        fields: `fields *`
      }
    };
  };
}
function exclude(exclude2) {
  const fieldsString = exclude2.join(",").replace(/\s/g, "");
  return (builder) => {
    return {
      ...builder,
      queryFields: {
        ...builder.queryFields,
        exclude: `exclude ${fieldsString}`
      }
    };
  };
}
function sort(field, direction = "asc") {
  return (builder) => {
    return {
      ...builder,
      queryFields: {
        ...builder.queryFields,
        sort: `sort ${String(field)} ${direction}`
      }
    };
  };
}
function limit(limit2) {
  return (builder) => {
    return {
      ...builder,
      queryFields: {
        ...builder.queryFields,
        limit: `limit ${limit2}`
      }
    };
  };
}
function offset(offset2) {
  return (builder) => {
    return {
      ...builder,
      queryFields: {
        ...builder.queryFields,
        offset: `offset ${offset2}`
      }
    };
  };
}
function search(search2) {
  return (builder) => {
    return {
      ...builder,
      queryFields: {
        ...builder.queryFields,
        search: `search "${encodeString(search2)}"`
      }
    };
  };
}
function encodeWhereParam(value, flag) {
  let v = null;
  if (typeof value === "boolean" || value === null) {
    return String(value);
  }
  if (typeof flag === "number") {
    if ((flag & 2 /* STRING */) === 2 /* STRING */) {
      v = `"${encodeString(value)}"`;
    }
    if ((flag & 6 /* STARTSWITH */) === 6 /* STARTSWITH */) {
      v += "*";
    }
    if ((flag & 10 /* ENDSWITH */) === 10 /* ENDSWITH */) {
      v = "*" + v;
    }
    if ((flag & 1 /* RAW */) === 1 /* RAW */) {
      v = value;
    }
  }
  if (typeof value === "string" && v === null) {
    v = `"${encodeString(value)}"`;
  }
  if (v === null) {
    v = value;
  }
  return v;
}
function getOp(flag) {
  if ((flag & 48 /* NAND */) === 48 /* NAND */) {
    return "!=";
  }
  if ((flag & 80 /* NOR */) === 80 /* NOR */) {
    return "!=";
  }
  return "=";
}
function encodeWhereInParam(values, flag) {
  const joined = values.map((v) => encodeWhereParam(v, flag)).join(",");
  if ((flag & 48 /* NAND */) === 48 /* NAND */) {
    return `[${joined}]`;
  }
  if ((flag & 80 /* NOR */) === 80 /* NOR */) {
    return `(${joined})`;
  }
  if ((flag & 32 /* AND */) === 32 /* AND */) {
    return `[${joined}]`;
  }
  if ((flag & 64 /* OR */) === 64 /* OR */) {
    return `(${joined})`;
  }
  if ((flag & 128 /* EXACT */) === 128 /* EXACT */) {
    return `{${joined}}`;
  }
  throw new Error("WhereInFlags not specified or invalid");
}
function where(key, op, value, flag) {
  return (builder) => {
    return {
      ...builder,
      queryFields: {
        ...builder.queryFields,
        where: [`${key} ${op} ${encodeWhereParam(value, flag)}`]
      }
    };
  };
}
function whereIn(key, values, flag = 64 /* OR */) {
  return (builder) => {
    return {
      ...builder,
      queryFields: {
        ...builder.queryFields,
        where: [`${key} ${getOp(flag)} ${encodeWhereInParam(values, flag)}`]
      }
    };
  };
}
function groupWhere(orAnd, ...operators) {
  return (builder) => {
    const sub = operators.flatMap((op) => [...op(builder).queryFields.where, ` ${orAnd} `]);
    if (sub.length === 0) return builder;
    sub.pop();
    return {
      ...builder,
      queryFields: {
        ...builder.queryFields,
        where: ["(", ...sub, ")"]
      }
    };
  };
}
function and(...operators) {
  return groupWhere("&", ...operators);
}
function or(...operators) {
  return groupWhere("|", ...operators);
}
function toStringMulti(builders) {
  return builders.map((b) => `query ${b.queryEndpoint} "${b.queryName}" { ${toStringSingle(b)} };`).join("");
}
function toStringSingle(builder) {
  const { where: where2, ...rest } = builder.queryFields;
  const w = where2.length > 0 ? "where " + where2.join("") + ";" : "";
  const r = Object.keys(rest).length > 0 ? Object.values(rest).join(";") + ";" : "";
  return r + w;
}
function encodeString(v) {
  return v.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
}

// src/index.ts
function apicalypse(builder, options = {}) {
  function getAxiosRequestConfig(url) {
    const opts = {
      queryMethod: "body",
      method: "post",
      ...options,
      url
    };
    const raw = builder.toApicalypseString();
    if (opts.queryMethod === "url") {
      opts.params = {
        apicalypse: encodeURIComponent(raw)
      };
    } else if (opts.queryMethod === "body") {
      opts.data = raw;
    }
    return opts;
  }
  return {
    execute(url) {
      return axios.create()(getAxiosRequestConfig(url));
    }
  };
}
function request() {
  function _pipe(...steps) {
    return steps.reduce((output, f) => f(output), newBuilder());
  }
  const pipe = (...steps) => {
    const builder = _pipe(...steps);
    return {
      execute(url, options = {}) {
        return apicalypse(builder, options).execute(url);
      },
      toApicalypseString() {
        return toStringSingle(builder);
      }
    };
  };
  const sub = (queryEndpoint, queryName) => {
    const pipe2 = (...steps) => {
      return _pipe(query(queryEndpoint, queryName), ...steps);
    };
    return {
      pipe: pipe2
    };
  };
  return {
    pipe,
    sub
  };
}
function multi(...builders) {
  return {
    toApicalypseString() {
      return toStringMulti(builders);
    },
    execute(url, options = {}) {
      return apicalypse(this, options).execute(url);
    }
  };
}
function newBuilder() {
  return {
    queryFields: {
      where: []
    },
    toApicalypseString() {
      return toStringSingle(this);
    }
  };
}
function isNamed(builder, name) {
  if (builder.name === name) {
    return true;
  }
  return false;
}
export {
  WhereFlags,
  WhereInFlags,
  and,
  exclude,
  fields,
  isNamed,
  limit,
  multi,
  offset,
  or,
  request,
  search,
  sort,
  where,
  whereIn
};