213 lines
7.5 KiB
JavaScript
213 lines
7.5 KiB
JavaScript
"use strict";
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
var utils_exports = {};
|
|
__export(utils_exports, {
|
|
applyMixins: () => applyMixins,
|
|
getColumnNameAndConfig: () => getColumnNameAndConfig,
|
|
getTableColumns: () => getTableColumns,
|
|
getTableLikeName: () => getTableLikeName,
|
|
getViewSelectedFields: () => getViewSelectedFields,
|
|
haveSameKeys: () => haveSameKeys,
|
|
isConfig: () => isConfig,
|
|
mapResultRow: () => mapResultRow,
|
|
mapUpdateSet: () => mapUpdateSet,
|
|
orderSelectedFields: () => orderSelectedFields
|
|
});
|
|
module.exports = __toCommonJS(utils_exports);
|
|
var import_column = require("./column.cjs");
|
|
var import_entity = require("./entity.cjs");
|
|
var import_sql = require("./sql/sql.cjs");
|
|
var import_subquery = require("./subquery.cjs");
|
|
var import_table = require("./table.cjs");
|
|
var import_view_common = require("./view-common.cjs");
|
|
function mapResultRow(columns, row, joinsNotNullableMap) {
|
|
const nullifyMap = {};
|
|
const result = columns.reduce(
|
|
(result2, { path, field }, columnIndex) => {
|
|
let decoder;
|
|
if ((0, import_entity.is)(field, import_column.Column)) {
|
|
decoder = field;
|
|
} else if ((0, import_entity.is)(field, import_sql.SQL)) {
|
|
decoder = field.decoder;
|
|
} else {
|
|
decoder = field.sql.decoder;
|
|
}
|
|
let node = result2;
|
|
for (const [pathChunkIndex, pathChunk] of path.entries()) {
|
|
if (pathChunkIndex < path.length - 1) {
|
|
if (!(pathChunk in node)) {
|
|
node[pathChunk] = {};
|
|
}
|
|
node = node[pathChunk];
|
|
} else {
|
|
const rawValue = row[columnIndex];
|
|
const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
|
|
if (joinsNotNullableMap && (0, import_entity.is)(field, import_column.Column) && path.length === 2) {
|
|
const objectName = path[0];
|
|
if (!(objectName in nullifyMap)) {
|
|
nullifyMap[objectName] = value === null ? (0, import_table.getTableName)(field.table) : false;
|
|
} else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== (0, import_table.getTableName)(field.table)) {
|
|
nullifyMap[objectName] = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result2;
|
|
},
|
|
{}
|
|
);
|
|
if (joinsNotNullableMap && Object.keys(nullifyMap).length > 0) {
|
|
for (const [objectName, tableName] of Object.entries(nullifyMap)) {
|
|
if (typeof tableName === "string" && !joinsNotNullableMap[tableName]) {
|
|
result[objectName] = null;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function orderSelectedFields(fields, pathPrefix) {
|
|
return Object.entries(fields).reduce((result, [name, field]) => {
|
|
if (typeof name !== "string") {
|
|
return result;
|
|
}
|
|
const newPath = pathPrefix ? [...pathPrefix, name] : [name];
|
|
if ((0, import_entity.is)(field, import_column.Column) || (0, import_entity.is)(field, import_sql.SQL) || (0, import_entity.is)(field, import_sql.SQL.Aliased)) {
|
|
result.push({ path: newPath, field });
|
|
} else if ((0, import_entity.is)(field, import_table.Table)) {
|
|
result.push(...orderSelectedFields(field[import_table.Table.Symbol.Columns], newPath));
|
|
} else {
|
|
result.push(...orderSelectedFields(field, newPath));
|
|
}
|
|
return result;
|
|
}, []);
|
|
}
|
|
function haveSameKeys(left, right) {
|
|
const leftKeys = Object.keys(left);
|
|
const rightKeys = Object.keys(right);
|
|
if (leftKeys.length !== rightKeys.length) {
|
|
return false;
|
|
}
|
|
for (const [index, key] of leftKeys.entries()) {
|
|
if (key !== rightKeys[index]) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function mapUpdateSet(table, values) {
|
|
const entries = Object.entries(values).filter(([, value]) => value !== void 0).map(([key, value]) => {
|
|
if ((0, import_entity.is)(value, import_sql.SQL) || (0, import_entity.is)(value, import_column.Column)) {
|
|
return [key, value];
|
|
} else {
|
|
return [key, new import_sql.Param(value, table[import_table.Table.Symbol.Columns][key])];
|
|
}
|
|
});
|
|
if (entries.length === 0) {
|
|
throw new Error("No values to set");
|
|
}
|
|
return Object.fromEntries(entries);
|
|
}
|
|
function applyMixins(baseClass, extendedClasses) {
|
|
for (const extendedClass of extendedClasses) {
|
|
for (const name of Object.getOwnPropertyNames(extendedClass.prototype)) {
|
|
if (name === "constructor")
|
|
continue;
|
|
Object.defineProperty(
|
|
baseClass.prototype,
|
|
name,
|
|
Object.getOwnPropertyDescriptor(extendedClass.prototype, name) || /* @__PURE__ */ Object.create(null)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function getTableColumns(table) {
|
|
return table[import_table.Table.Symbol.Columns];
|
|
}
|
|
function getViewSelectedFields(view) {
|
|
return view[import_view_common.ViewBaseConfig].selectedFields;
|
|
}
|
|
function getTableLikeName(table) {
|
|
return (0, import_entity.is)(table, import_subquery.Subquery) ? table._.alias : (0, import_entity.is)(table, import_sql.View) ? table[import_view_common.ViewBaseConfig].name : (0, import_entity.is)(table, import_sql.SQL) ? void 0 : table[import_table.Table.Symbol.IsAlias] ? table[import_table.Table.Symbol.Name] : table[import_table.Table.Symbol.BaseName];
|
|
}
|
|
function getColumnNameAndConfig(a, b) {
|
|
return {
|
|
name: typeof a === "string" && a.length > 0 ? a : "",
|
|
config: typeof a === "object" ? a : b
|
|
};
|
|
}
|
|
const _ = {};
|
|
const __ = {};
|
|
function isConfig(data) {
|
|
if (typeof data !== "object" || data === null)
|
|
return false;
|
|
if (data.constructor.name !== "Object")
|
|
return false;
|
|
if ("logger" in data) {
|
|
const type = typeof data["logger"];
|
|
if (type !== "boolean" && (type !== "object" || typeof data["logger"]["logQuery"] !== "function") && type !== "undefined")
|
|
return false;
|
|
return true;
|
|
}
|
|
if ("schema" in data) {
|
|
const type = typeof data["logger"];
|
|
if (type !== "object" && type !== "undefined")
|
|
return false;
|
|
return true;
|
|
}
|
|
if ("casing" in data) {
|
|
const type = typeof data["logger"];
|
|
if (type !== "string" && type !== "undefined")
|
|
return false;
|
|
return true;
|
|
}
|
|
if ("mode" in data) {
|
|
if (data["mode"] !== "default" || data["mode"] !== "planetscale" || data["mode"] !== void 0)
|
|
return false;
|
|
return true;
|
|
}
|
|
if ("connection" in data) {
|
|
const type = typeof data["connection"];
|
|
if (type !== "string" && type !== "object" && type !== "undefined")
|
|
return false;
|
|
return true;
|
|
}
|
|
if ("client" in data) {
|
|
const type = typeof data["client"];
|
|
if (type !== "object" && type !== "function" && type !== "undefined")
|
|
return false;
|
|
return true;
|
|
}
|
|
if (Object.keys(data).length === 0)
|
|
return true;
|
|
return false;
|
|
}
|
|
// Annotate the CommonJS export names for ESM import in node:
|
|
0 && (module.exports = {
|
|
applyMixins,
|
|
getColumnNameAndConfig,
|
|
getTableColumns,
|
|
getTableLikeName,
|
|
getViewSelectedFields,
|
|
haveSameKeys,
|
|
isConfig,
|
|
mapResultRow,
|
|
mapUpdateSet,
|
|
orderSelectedFields
|
|
});
|
|
//# sourceMappingURL=utils.cjs.map
|