@palmares/drizzle-engine
Version:
This is the engine that wraps the hole drizzle interface in a way palmares can understand and have full control of
144 lines (142 loc) • 6.58 kB
JavaScript
var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
// src/query.ts
import { adapterGetQuery, adapterOrderingQuery, adapterQuery, adapterRemoveQuery, adapterSearchQuery, adapterSetQuery } from "@palmares/databases";
import { and, asc, between, desc, eq, gt, gte, ilike, inArray, isNotNull, isNull, like, lt, lte, not, notBetween, notIlike, notInArray, notLike, or } from "drizzle-orm";
var getQuery = adapterGetQuery({
// eslint-disable-next-line ts/require-await
queryData: /* @__PURE__ */ __name(async (engine, args) => {
const selectArgs = Array.isArray(args.fields) && args.fields.length > 0 ? [
args.fields.reduce((acc, field) => ({
...acc,
[]: args.modelOfEngineInstance[field]
}), {})
] : [];
let query2 = engine.instance.instance.select(...selectArgs).from(args.modelOfEngineInstance);
if (args.search) {
const searchAsObjectValues = Object.values(args.search);
if (searchAsObjectValues.length > 0) query2 = query2.where(and(...searchAsObjectValues));
}
if (typeof args.limit === "number") query2 = query2.limit(args.limit);
if (typeof args.offset === "number") query2 = query2.offset(args.offset);
if ((args.ordering || []).length > 0) query2 = query2.orderBy(...args.ordering || []);
return query2;
}, "queryData")
});
var setQuery = adapterSetQuery({
queryData: /* @__PURE__ */ __name(async (engine, args) => {
const engineInstanceOrTransaction = args.transaction || engine.instance.instance;
if (args.search && Object.keys(args.search).length > 0) {
if (engine.instance.mainType === "sqlite" || engine.instance.mainType === "postgres") {
return (await engineInstanceOrTransaction.update(args.modelOfEngineInstance).set(args.data[0]).where(and(...Object.values(args.search))).returning() || []).map((data) => [
false,
data
]);
} else {
await engineInstanceOrTransaction.update(args.modelOfEngineInstance).set(args.data[0]).where(and(...Object.values(args.search)));
const search2 = await engineInstanceOrTransaction.select().from(args.modelOfEngineInstance).where(and(...Object.values(args.search)));
return search2.map((each) => [
false,
each
]);
}
}
const inserts = await Promise.all(args.data.map(async (eachData) => {
if (engine.instance.mainType === "sqlite" || engine.instance.mainType === "postgres") {
return [
true,
(await engineInstanceOrTransaction.insert(args.modelOfEngineInstance).values(eachData).returning())[0]
];
}
const results = await engineInstanceOrTransaction.insert(args.modelOfEngineInstance).values(eachData).$returningId();
const insertedData = results?.[0];
if (!insertedData) return void 0;
const primaryKey = Object.keys(insertedData)[0];
const primaryKeyValue = insertedData[primaryKey];
const searchForInsertedData = eq(args.modelOfEngineInstance[primaryKey], primaryKeyValue);
const searchResult = await engineInstanceOrTransaction.select().from(args.modelOfEngineInstance).where(searchForInsertedData);
if ((searchResult?.length || []) <= 0) return void 0;
return [
true,
searchResult[0]
];
}));
return inserts.filter((insert) => Array.isArray(insert));
}, "queryData")
});
var removeQuery = adapterRemoveQuery({
queryData: /* @__PURE__ */ __name(async (engine, args) => {
const engineInstanceOrTransaction = args.transaction || engine.instance.instance;
if (engine.instance.mainType === "sqlite" || engine.instance.mainType === "postgres") return engineInstanceOrTransaction.delete(args.modelOfEngineInstance).where(and(...Object.values(args.search))).returning();
const dataToBeDeleted = await engine.instance.instance.select().from(args.modelOfEngineInstance).where(and(...Object.values(args.search)));
await engineInstanceOrTransaction.delete(args.modelOfEngineInstance).where(and(...Object.values(args.search)));
return dataToBeDeleted;
}, "queryData")
});
var order = adapterOrderingQuery({
// eslint-disable-next-line ts/require-await
parseOrdering: /* @__PURE__ */ __name(async (model, ordering) => {
return ordering.map((order2) => {
const isDescending = order2.startsWith("-");
return isDescending ? desc(model[order2.slice(1)]) : asc(model[order2]);
});
}, "parseOrdering")
});
var search = adapterSearchQuery({
// eslint-disable-next-line ts/require-await
parseSearchFieldValue: /* @__PURE__ */ __name(async (operationType, key, model, value, result, options) => {
switch (operationType) {
case "like": {
if (options?.ignoreCase) result[key] = ilike(model[key], value);
else if (options?.isNot && options.ignoreCase) result[key] = notIlike(model[key], value);
else if (options?.isNot) result[key] = notLike(model[key], value);
else result[key] = like(model[key], value);
return;
}
case "is":
if (value === null && options?.isNot) {
result[key] = isNotNull(model[key]);
return;
} else if (value === null) {
result[key] = isNull(model[key]);
return;
} else if (options?.isNot) result[key] = not(eq(model[key], value));
else result[key] = eq(model[key], value);
return;
case "in":
if (options?.isNot) result[key] = notInArray(model[key], value);
else result[key] = inArray(model[key], value);
return;
case "between":
if (options?.isNot) result[key] = notBetween(model[key], value, value);
else result[key] = between(model[key], value, value);
return;
case "and":
result[key] = and(eq(model[key], value), eq(model[key], value));
return;
case "or":
result[key] = or(eq(model[key], value), eq(model[key], value));
return;
case "greaterThan":
if (options?.equals) result[key] = gte(model[key], value);
else result[key] = gt(model[key], value);
return;
case "lessThan":
if (options?.equals) result[key] = lte(model[key], value);
else result[key] = lt(model[key], value);
return;
default:
result[key] = eq(model[key], value);
}
}, "parseSearchFieldValue")
});
var query = adapterQuery({
search: new search(),
ordering: new order(),
get: new getQuery(),
set: new setQuery(),
remove: new removeQuery()
});
export {
query
};