@phalcode/ts-apicalypse
Version:
A Typescript client and request builder for Apicalypse
367 lines (362 loc) • 9.25 kB
JavaScript
;
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/index.ts
var index_exports = {};
__export(index_exports, {
WhereFlags: () => WhereFlags,
WhereInFlags: () => WhereInFlags,
and: () => and,
exclude: () => exclude,
fields: () => fields,
isNamed: () => isNamed,
limit: () => limit,
multi: () => multi,
offset: () => offset,
or: () => or,
request: () => request,
search: () => search,
sort: () => sort,
where: () => where,
whereIn: () => whereIn
});
module.exports = __toCommonJS(index_exports);
var import_axios = __toESM(require("axios"), 1);
// 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 import_axios.default.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;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
WhereFlags,
WhereInFlags,
and,
exclude,
fields,
isNamed,
limit,
multi,
offset,
or,
request,
search,
sort,
where,
whereIn
});