qubu 0.0.0 → 0.3.3

package/dist/column-CXMxx8Hq.mjs

@@ -0,0 +1,118 @@
+import { a as assertDialectCapability } from "./json-CUZlv4HT.mjs";
+//#region src/core/fragment.ts
+function fragment(render) {
+	return Object.freeze({ render });
+}
+function sequence(parts, separator = " ") {
+	return fragment((context) => {
+		let first = true;
+		for (const part of parts) {
+			if (!first) context.append(separator);
+			context.render(part);
+			first = false;
+		}
+	});
+}
+function parenthesize(part) {
+	return fragment((context) => {
+		context.append("(");
+		context.render(part);
+		context.append(")");
+	});
+}
+function isFragment(value) {
+	return typeof value === "object" && value !== null && "render" in value && typeof value.render === "function";
+}
+//#endregion
+//#region src/expressions/types.ts
+/** Runtime/type-level proof that an expression is safe to use in schema SQL. */
+const schemaExpressionBrand = Symbol("qubu.schema-expression");
+/** Add a concrete dialect requirement without dropping expression metadata. */
+function withDialectCapability(expression, capability) {
+	const wrapped = makeExpression(expression.expressionKind, (context) => {
+		assertDialectCapability(context.dialect, capability);
+		context.render(expression);
+	});
+	return isSchemaExpression(expression) ? markSchemaExpression(wrapped) : wrapped;
+}
+function makeExpression(expressionKind, render, expressionCategory) {
+	return Object.freeze({
+		expressionKind,
+		...expressionCategory ? { expressionCategory } : {},
+		...fragment(render)
+	});
+}
+/** Mark a query-only expression category without changing its SQL renderer. */
+function markExpressionCategory(expression, category) {
+	return Object.freeze({
+		...expression,
+		expressionCategory: category
+	});
+}
+/**
+* Mark a built-in or explicitly audited renderer as schema-deterministic.
+* Prefer {@link defineSchemaExpression} for application extensions because it
+* supplies a restricted schema rendering context.
+*/
+function makeSchemaExpression(expressionKind, render) {
+	const expression = makeExpression(expressionKind, render);
+	return Object.freeze({
+		...expression,
+		[schemaExpressionBrand]: true
+	});
+}
+/** Add the schema-determinism brand to an explicitly audited expression. */
+function markSchemaExpression(expression) {
+	if (isSchemaExpression(expression)) return expression;
+	return Object.freeze({
+		...expression,
+		[schemaExpressionBrand]: true
+	});
+}
+/** Test the runtime brand used by schema rendering and validation. */
+function isSchemaExpression(value) {
+	return typeof value === "object" && value !== null && schemaExpressionBrand in value && value[schemaExpressionBrand] === true;
+}
+function isExpression(value) {
+	return typeof value === "object" && value !== null && "expressionKind" in value && "render" in value && typeof value.render === "function";
+}
+//#endregion
+//#region src/core/primitives/identifier.ts
+function identifier(name) {
+	return fragment((context) => context.append(context.dialect.quoteIdentifier(name)));
+}
+function qualifiedIdentifier(...parts) {
+	return fragment((context) => {
+		parts.forEach((part, index) => {
+			if (index > 0) context.append(".");
+			context.append(context.dialect.quoteIdentifier(part));
+		});
+	});
+}
+//#endregion
+//#region src/expressions/column.ts
+function createColumnReference(columnName, sourceReference, fieldName) {
+	const expression = makeSchemaExpression("column", (context) => {
+		if (context.renderColumnReference) {
+			context.renderColumnReference(columnName);
+			return;
+		}
+		context.render(sourceReference);
+		context.append(".");
+		context.render(identifier(columnName));
+	});
+	return Object.freeze({
+		...expression,
+		fieldName,
+		columnName
+	});
+}
+function isColumnReference(value) {
+	return typeof value === "object" && value !== null && "expressionKind" in value && value.expressionKind === "column";
+}
+/** Turn an expression into a fragment that renders it without changing it. */
+function expressionFragment(expression) {
+	return fragment((context) => context.render(expression));
+}
+//#endregion
+export { qualifiedIdentifier as a, makeExpression as c, markSchemaExpression as d, withDialectCapability as f, sequence as g, parenthesize as h, identifier as i, makeSchemaExpression as l, isFragment as m, expressionFragment as n, isExpression as o, fragment as p, isColumnReference as r, isSchemaExpression as s, createColumnReference as t, markExpressionCategory as u };