← Files RivetARCHIVED FILE
node_modules/drizzle-orm/utils.cjs
16.6 KB · Nov 7, 2026 · 13:16 UTC
Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
const require_entity = require('./entity.cjs');
const require_column = require('./column.cjs');
const require_table = require('./table.cjs');
const require_sql_sql = require('./sql/sql.cjs');
const require_subquery = require('./subquery.cjs');
const require_view_common = require('./view-common.cjs');
//#region src/utils.ts
/** @internal */
function mapResultRow(columns, row, joinsNotNullableMap) {
const nullifyMap = {};
const result = columns.reduce((result, { path, field, codec, arrayDimensions }, columnIndex) => {
let decoder;
if (require_entity.is(field, require_column.Column)) decoder = field;
else if (require_entity.is(field, require_sql_sql.SQL)) decoder = field.decoder;
else if (require_entity.is(field, require_subquery.Subquery)) decoder = field._.sql.decoder;
else decoder = field.sql.decoder;
let node = result;
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(codec ? codec(rawValue, arrayDimensions) : rawValue);
if (joinsNotNullableMap && require_entity.is(field, require_column.Column) && path.length === 2) {
const objectName = path[0];
if (!(objectName in nullifyMap)) nullifyMap[objectName] = value === null ? require_table.getTableName(field.table) : false;
else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== require_table.getTableName(field.table)) nullifyMap[objectName] = false;
}
}
return result;
}, {});
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;
}
/** @internal bypass bundle-time filtering */
const FnConstructor = Object.getPrototypeOf(() => null).constructor;
/** @internal */
function makeJitQueryMapperInner(columns, joinsNotNullableMap = {}) {
const preFn = [];
const fn = [];
fn.push(`const [ ${columns.map((_, i) => `c${i}`).join(", ")} ] = rows[i];`);
const nullifyMap = {};
const objectIds = {};
const decodes = Array.from({ length: columns.length });
for (let idx = 0; idx < columns.length; ++idx) {
const { field, path, codec, arrayDimensions } = columns[idx];
let decoder;
let decoderStr;
let decoderFieldDestructure;
let isColumn = false;
if (require_entity.is(field, require_column.Column)) {
isColumn = true;
decoder = field;
decoderFieldDestructure = `field: decoder${idx}`;
} else if (require_entity.is(field, require_sql_sql.SQL)) {
decoder = field.decoder;
decoderFieldDestructure = `field: { decoder: decoder${idx} }`;
} else if (require_entity.is(field, require_subquery.Subquery)) {
decoder = field._.sql.decoder;
decoderFieldDestructure = `field: { _: { sql: { decoder: decoder${idx} } } }`;
} else {
decoder = field.sql.decoder;
decoderFieldDestructure = `field: { sql: { decoder: decoder${idx} } }`;
}
decoderStr = `decoder${idx}.mapFromDriverValue`;
if (decoder.mapFromDriverValue.isNoop) decoderStr = "";
if (decoderStr) preFn.push(`const { ${decoderFieldDestructure}${codec ? `, codec: codec${idx}` : ""} } = columns[${idx}];`);
else if (codec) preFn.push(`const { codec: codec${idx} } = columns[${idx}];`);
const colStr = `c${idx}`;
let decodedValue = colStr;
if (codec) decodedValue = `codec${idx}(${decodedValue}, ${arrayDimensions})`;
if (decoderStr) decodedValue = `${decoderStr}(${decodedValue})`;
decodes[idx] = colStr === decodedValue ? `${colStr}` : `${colStr} === null ? ${colStr} : ${decodedValue}`;
if (path.length !== 2 || !isColumn) continue;
if (objectIds[path[0]] === void 0) objectIds[path[0]] = [`c${idx}`];
else objectIds[path[0]]?.push(`c${idx}`);
const [objectName] = path;
const tableName = require_table.getTableName(field.table);
nullifyMap[objectName] = joinsNotNullableMap[tableName] ? false : typeof nullifyMap[objectName] === "string" ? nullifyMap[objectName] === tableName ? tableName : false : tableName;
}
fn.push(`mapped[i] = {`);
let currentObjectPath = [];
for (let idx = 0; idx < columns.length; ++idx) {
const { path } = columns[idx];
const jsonPath = path.map((e) => JSON.stringify(e));
const decodedValue = decodes[idx];
const objectPath = path.slice(0, -1);
let commonLen = 0;
while (commonLen < currentObjectPath.length && commonLen < objectPath.length && currentObjectPath[commonLen] === objectPath[commonLen]) commonLen++;
for (let d = currentObjectPath.length - 1; d >= commonLen; --d) fn.push(`${" ".repeat(d + 1)}},`);
for (let d = commonLen; d < objectPath.length; ++d) fn.push(`${" ".repeat(d + 1)}${jsonPath[d]}: ${d === 0 && objectPath.length === 1 && typeof nullifyMap[path[0]] === "string" ? `${objectIds[path[0]]?.map((c) => `${c} === null`).join(" && ")} ? null : {` : "{"}`);
currentObjectPath = objectPath;
fn.push(`${" ".repeat(path.length)}${jsonPath[path.length - 1]}: ${decodedValue},`);
}
for (let d = currentObjectPath.length - 1; d >= 0; --d) fn.push(`${" ".repeat(d + 1)}},`);
fn.push(`};`);
return `${preFn.length ? `${preFn.join("\n ")}\n\t` : ""}for (let i = 0; i < length; ++i) {
${fn.join("\n ")}
}`;
}
function makeJitQueryMapper(columns, joinsNotNullableMap) {
const internals = `\t"use strict";
const { columns } = this;
const { length } = rows;
const mapped = Array.from({ length });
${makeJitQueryMapperInner(columns, joinsNotNullableMap)}
return mapped;
//# sourceURL=drizzle:jit-query-mapper`;
return Object.assign(new FnConstructor("rows", internals).bind({ columns }), { body: `function jitQueryMapper (rows) {\n${internals}\n}` });
}
/** @internal */
function jitCompatCheck(isEnabled) {
if (!isEnabled) return false;
try {
const res = new FnConstructor("input", "\"use strict\"; return input;")(true);
if (res !== true) {
console.warn("Unable to use jit mappers due to incompatibility: corrupted jit function output.\nFalling back to premade mappers.\nError details:");
console.error(`Expected to receive \`true\`, got: ${res}`);
}
return true;
} catch (e) {
console.warn("Unable to use jit mappers due to incompatibility.\nFalling back to premade mappers.\nError details:");
console.error(e);
return false;
}
}
function makeDefaultQueryMapper(columns, joinsNotNullableMap) {
const interpretedData = columns.map(({ field, codec, arrayDimensions, path }) => {
let processNullifyMap;
let decoderSrc;
if (require_entity.is(field, require_column.Column)) {
decoderSrc = field;
if (joinsNotNullableMap && path.length === 2) {
const objectName = path[0];
processNullifyMap = (nullifyMap, value) => {
if (!(objectName in nullifyMap)) nullifyMap[objectName] = value === null ? require_table.getTableName(field.table) : false;
else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== require_table.getTableName(field.table)) nullifyMap[objectName] = false;
};
}
} else if (require_entity.is(field, require_sql_sql.SQL)) decoderSrc = field.decoder;
else if (require_entity.is(field, require_subquery.Subquery)) decoderSrc = field._.sql.decoder;
else decoderSrc = field.sql.decoder;
let decoder;
if (decoderSrc.mapFromDriverValue.isNoop) decoder = codec ? (v) => codec(v, arrayDimensions) : void 0;
else decoder = codec ? (v) => decoderSrc.mapFromDriverValue(codec(v, arrayDimensions)) : (v) => decoderSrc.mapFromDriverValue(v);
return [decoder, processNullifyMap];
});
return ((rows) => rows.map((row) => {
const nullifyMap = {};
const result = columns.reduce((result, { path }, columnIndex) => {
let node = result;
for (const [pathChunkIndex, pathChunk] of path.entries()) if (pathChunkIndex < path.length - 1) {
if (!(pathChunk in node)) node[pathChunk] = {};
node = node[pathChunk];
} else {
const [decoder, processNullifyMap] = interpretedData[columnIndex];
const rawValue = row[columnIndex];
const value = node[pathChunk] = rawValue === null ? null : decoder ? decoder(rawValue) : rawValue;
processNullifyMap?.(nullifyMap, value);
}
return result;
}, {});
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 make$ReturningResponseMapper(returningIds, generatedIds) {
if (!returningIds) return;
return ({ insertId, affectedRows }) => {
const returningResponse = [];
let j = 0;
for (let i = insertId; i < insertId + affectedRows; i++) {
for (const column of returningIds) {
const key = returningIds[0].path[0];
if (require_entity.is(column.field, require_column.Column)) {
if (column.field.primary && column.field.autoIncrement) returningResponse.push({ [key]: i });
if (column.field.defaultFn && generatedIds) returningResponse.push({ [key]: generatedIds[j][key] });
}
}
j++;
}
return returningResponse;
};
}
/** @internal */
function orderSelectedFields(fields, pathPrefix, codecs) {
return Object.entries(fields).reduce((result, [name, field]) => {
if (typeof name !== "string") return result;
const newPath = pathPrefix ? [...pathPrefix, name] : [name];
if (require_entity.is(field, require_column.Column)) result.push({
path: newPath,
field,
codec: codecs?.get(field, "normalize"),
arrayDimensions: field.dimensions,
column: field
});
else if (require_entity.is(field, require_sql_sql.SQL) || require_entity.is(field, require_sql_sql.SQL.Aliased)) {
const col = getColumnFromDecoder(field);
result.push(col ? {
path: newPath,
field,
codec: codecs?.get(col, "normalize"),
arrayDimensions: col.dimensions,
column: col
} : {
path: newPath,
field
});
} else if (require_entity.is(field, require_subquery.Subquery)) {
let column;
const entry = Object.values(field._.selectedFields)[0];
let fieldDecoder;
if (require_entity.is(entry, require_column.Column)) {
column = entry;
fieldDecoder = entry;
} else if (require_entity.is(entry, require_sql_sql.SQL)) {
column = getColumnFromDecoder(entry);
fieldDecoder = entry.decoder;
} else {
column = getColumnFromDecoder(entry);
fieldDecoder = entry.sql.decoder;
}
if (fieldDecoder) field._.sql.decoder = fieldDecoder;
result.push(column ? {
path: newPath,
field,
codec: codecs?.get(column, "normalize"),
arrayDimensions: column.dimensions,
column
} : {
path: newPath,
field
});
} else if (require_entity.is(field, require_table.Table)) result.push(...orderSelectedFields(field[require_table.Table.Symbol.Columns], newPath, codecs));
else result.push(...orderSelectedFields(field, newPath, codecs));
return result;
}, []);
}
function getColumnFromDecoder(source) {
const query = source.getSQL();
if (require_entity.is(query.decoder, require_column.Column)) return query.decoder;
}
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;
}
/** @internal */
function mapUpdateSet(table, values) {
const entries = Object.entries(values).filter(([, value]) => value !== void 0).map(([key, value]) => {
if (require_entity.is(value, require_sql_sql.SQL) || require_entity.is(value, require_column.Column)) return [key, value];
else return [key, new require_sql_sql.Param(value, table[require_table.Table.Symbol.Columns][key])];
});
if (entries.length === 0) throw new Error("No values to set");
return Object.fromEntries(entries);
}
/** @internal */
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) || Object.create(null));
}
}
/**
* @deprecated
* Use `getColumns` instead
*/
function getTableColumns(table) {
return table[require_table.Table.Symbol.Columns];
}
function getViewSelectedFields(view) {
return view[require_view_common.ViewBaseConfig].selectedFields;
}
function getColumns(table) {
return require_entity.is(table, require_table.Table) ? table[require_table.Table.Symbol.Columns] : require_entity.is(table, require_sql_sql.View) ? table[require_view_common.ViewBaseConfig].selectedFields : table._.selectedFields;
}
/** @internal */
function getTableLikeName(table) {
return require_entity.is(table, require_subquery.Subquery) ? table._.alias : require_entity.is(table, require_sql_sql.View) ? table[require_view_common.ViewBaseConfig].name : require_entity.is(table, require_sql_sql.SQL) ? void 0 : table[require_table.Table.Symbol.IsAlias] ? table[require_table.Table.Symbol.Name] : table[require_table.Table.Symbol.BaseName];
}
/** @internal */
function getColumnNameAndConfig(a, b) {
return {
name: typeof a === "string" && a.length > 0 ? a : "",
config: typeof a === "object" ? a : b
};
}
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["schema"];
if (type !== "object" && type !== "undefined") return false;
return true;
}
if ("relations" in data) {
const type = typeof data["relations"];
if (type !== "object" && type !== "undefined") 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 ("jit" in data) {
const type = typeof data["jit"];
if (type !== "boolean" && type !== "undefined") return false;
return true;
}
if ("codecs" in data) {
const type = typeof data["connection"];
if (type !== "object" && type !== "undefined") return false;
return true;
}
if (Object.keys(data).length === 0) return true;
return false;
}
const textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder();
function assertUnreachable(_x) {
throw new Error("Didn't expect to get here");
}
function isWithEnum(value) {
return (typeof value === "object" && value !== null || typeof value === "function") && "enumValues" in value && Array.isArray(value.enumValues) && value.enumValues.length > 0;
}
const CONSTANTS = {
INT8_MIN: -128,
INT8_MAX: 127,
INT8_UNSIGNED_MAX: 255,
INT16_MIN: -32768,
INT16_MAX: 32767,
INT16_UNSIGNED_MAX: 65535,
INT24_MIN: -8388608,
INT24_MAX: 8388607,
INT24_UNSIGNED_MAX: 16777215,
INT32_MIN: -2147483648,
INT32_MAX: 2147483647,
INT32_UNSIGNED_MAX: 4294967295,
INT48_MIN: -0x800000000000,
INT48_MAX: 0x7fffffffffff,
INT48_UNSIGNED_MAX: 0xffffffffffff,
INT64_MIN: -9223372036854775808n,
INT64_MAX: 9223372036854775807n,
INT64_UNSIGNED_MAX: 18446744073709551615n
};
function base64ToUint8Array(base64) {
if (!base64) return new Uint8Array(0);
const binary = atob(base64);
const len = binary.length;
const bytes = new Uint8Array(len);
for (let i = 0; i < len; ++i) bytes[i] = binary.charCodeAt(i);
return bytes;
}
//#endregion
exports.CONSTANTS = CONSTANTS;
exports.FnConstructor = FnConstructor;
exports.applyMixins = applyMixins;
exports.assertUnreachable = assertUnreachable;
exports.base64ToUint8Array = base64ToUint8Array;
exports.getColumnFromDecoder = getColumnFromDecoder;
exports.getColumnNameAndConfig = getColumnNameAndConfig;
exports.getColumns = getColumns;
exports.getTableColumns = getTableColumns;
exports.getTableLikeName = getTableLikeName;
exports.getViewSelectedFields = getViewSelectedFields;
exports.haveSameKeys = haveSameKeys;
exports.isConfig = isConfig;
exports.isWithEnum = isWithEnum;
exports.jitCompatCheck = jitCompatCheck;
exports.make$ReturningResponseMapper = make$ReturningResponseMapper;
exports.makeDefaultQueryMapper = makeDefaultQueryMapper;
exports.makeJitQueryMapper = makeJitQueryMapper;
exports.mapResultRow = mapResultRow;
exports.mapUpdateSet = mapUpdateSet;
exports.orderSelectedFields = orderSelectedFields;
exports.textDecoder = textDecoder;
//# sourceMappingURL=utils.cjs.mapSHA-256: f8904fea45ac154526ad07fc3d9f45f27ed7d97d0de540f0d59c1159c889f6a7