qubu 0.6.0 → 0.6.2

package/dist/registry-BRcUuazJ.mjs

@@ -1,256 +0,0 @@
-import { t as standardDialect } from "./standard-DfcZEVOj.mjs";
-import { _ as isSchemaExpression, h as snakeCaseIdentifier, r as isColumnReference, x as markSchemaExpression, y as makeSchemaExpression } from "./column-r1Y4ivwt.mjs";
-import { n as isValueExpression } from "./value-D14I_XgL.mjs";
-//#region src/schema/expressions.ts
-/** Error raised before a schema expression can become persisted SQL. */
-var SchemaExpressionError = class extends TypeError {
-	code;
-	mode;
-	constructor(code, message, mode) {
-		super(message);
-		this.name = "SchemaExpressionError";
-		this.code = code;
-		this.mode = mode;
-	}
-};
-/**
-* Normalize only line endings. Whitespace, quoting, and every other byte of a raw schema expression
-* remain under the extension author's control.
-*/
-function normalizeSchemaSql(sql) {
-	return sql.replace(/\r\n?/g, "\n");
-}
-function schemaExpression(expression) {
-	return markSchemaExpression(expression);
-}
-/**
-* Define an extension with the restricted schema context. This is the typed alternative to
-* {@link unsafeSchemaSql} for deterministic custom syntax.
-*/
-function defineSchemaExpression(kind, render) {
-	return makeSchemaExpression(kind, (context) => render(context));
-}
-function unsafeSchemaSql(dialectOrOptions, sql) {
-	const dialect = typeof dialectOrOptions === "string" ? dialectOrOptions : dialectOrOptions.dialect;
-	const source = typeof dialectOrOptions === "string" ? sql : dialectOrOptions.sql;
-	if (!dialect) throw new TypeError("unsafeSchemaSql() requires a dialect tag");
-	if (source === void 0) throw new TypeError("unsafeSchemaSql() requires SQL text");
-	const normalized = normalizeSchemaSql(source);
-	const expression = makeSchemaExpression("unsafe", (context) => context.append(normalized));
-	return Object.freeze({
-		...expression,
-		schemaSqlDialect: dialect,
-		schemaSql: normalized
-	});
-}
-/** Identify a dialect-tagged raw schema expression. */
-function isUnsafeSchemaSql(value) {
-	return isSchemaExpression(value) && value.expressionKind === "unsafe" && typeof value.schemaSqlDialect === "string" && typeof value.schemaSql === "string";
-}
-function renderSchemaExpression(expression, optionsOrMode, dialectOption) {
-	const options = typeof optionsOrMode === "string" ? {
-		mode: optionsOrMode,
-		dialect: dialectOption
-	} : optionsOrMode;
-	const dialect = options.dialect ?? standardDialect();
-	if (!isSchemaExpression(expression)) throw new SchemaExpressionError("not-deterministic", "Only branded deterministic expressions can be rendered as schema SQL", options.mode);
-	assertSupportedExpression(expression, options.mode);
-	let text = "";
-	const context = {
-		dialect,
-		projectionMode: "result",
-		schemaMode: options.mode,
-		append(value) {
-			text += value;
-		},
-		parameter() {
-			throw new SchemaExpressionError("parameter", "Schema expressions cannot render query parameters", options.mode);
-		},
-		literal(value) {
-			text += renderSchemaLiteral(dialect, value, options.mode);
-		},
-		renderColumnReference(columnName) {
-			if (options.mode === "default") throw new SchemaExpressionError("column-not-allowed", "Default expressions cannot reference table columns", options.mode);
-			text += dialect.quoteIdentifier(columnName);
-		},
-		render(part) {
-			renderSchemaPart(context, part, options.mode);
-		},
-		renderRelation() {
-			throw new SchemaExpressionError("unsupported-expression", "Schema expressions cannot contain subqueries", options.mode);
-		}
-	};
-	renderSchemaPart(context, expression, options.mode);
-	return Object.freeze({
-		text,
-		parameters: Object.freeze([])
-	});
-}
-/** Convenience form for callers that only need the SQL text. */
-function renderSchemaSql(expression, options) {
-	return renderSchemaExpression(expression, options).text;
-}
-function renderSchemaPart(context, part, mode) {
-	if (isValueExpression(part)) {
-		context.literal(part.value);
-		return;
-	}
-	if (isColumnReference(part)) {
-		context.renderColumnReference(part.columnName);
-		return;
-	}
-	if (isUnsafeSchemaSql(part)) {
-		if (part.schemaSqlDialect !== context.dialect.name) throw new SchemaExpressionError("dialect-mismatch", `Schema SQL is tagged for "${part.schemaSqlDialect}" but rendered for "${context.dialect.name}"`, mode);
-		context.append(part.schemaSql);
-		return;
-	}
-	if (!isSchemaExpression(part)) throw new SchemaExpressionError("not-deterministic", "Schema expressions may only compose branded expressions, columns, and literals", mode);
-	assertSupportedExpression(part, mode);
-	part.render(context);
-}
-function assertSupportedExpression(expression, mode) {
-	if (expression.expressionKind === "subquery" || expression.expressionCategory) throw new SchemaExpressionError("unsupported-expression", "Aggregates, windows, and subqueries are not valid schema expressions", mode);
-}
-function renderSchemaLiteral(dialect, value, mode) {
-	if (dialect.renderSchemaLiteral) {
-		const rendered = dialect.renderSchemaLiteral(value);
-		if (typeof rendered !== "string" || rendered.includes("?")) throw new SchemaExpressionError("invalid-literal", "A schema literal renderer must return parameter-free SQL text", mode);
-		return rendered;
-	}
-	if (value === null) return "NULL";
-	if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
-	if (typeof value === "string") return `'${value.replaceAll("'", "''")}'`;
-	if (typeof value === "bigint") return String(value);
-	if (typeof value === "number") {
-		if (!Number.isFinite(value)) throw new SchemaExpressionError("unsupported-value", "Schema literals require finite numbers", mode);
-		return Object.is(value, -0) ? "0" : String(value);
-	}
-	throw new SchemaExpressionError("unsupported-value", `Unsupported schema literal type: ${value === void 0 ? "undefined" : typeof value}`, mode);
-}
-//#endregion
-//#region src/schema/registry.ts
-/** The first naming-policy version used by schema metadata. */
-const schemaNamingPolicyVersion = 1;
-/**
-* The built-in naming policy for schema-generated physical names.
-*
-* Explicit names supplied to `table()` remain unchanged. The policy is used by tooling when it
-* needs a physical name for a logical table ID.
-*/
-const defaultSchemaNamingPolicy = Object.freeze({
-	version: 1,
-	tableName: snakeCaseIdentifier
-});
-/** Error thrown when a root schema fails registry or naming validation. */
-var SchemaValidationError = class extends Error {
-	name = "SchemaValidationError";
-	diagnostics;
-	/** Alias matching validation libraries that call findings "issues". */
-	issues;
-	constructor(diagnostics) {
-		const frozenDiagnostics = Object.freeze(diagnostics.map((diagnostic) => Object.freeze({
-			...diagnostic,
-			path: Object.freeze([...diagnostic.path]),
-			relatedPaths: diagnostic.relatedPaths ? Object.freeze(diagnostic.relatedPaths.map((path) => Object.freeze([...path]))) : void 0
-		})));
-		super(frozenDiagnostics.map((diagnostic) => diagnostic.message).join("\n"));
-		this.diagnostics = frozenDiagnostics;
-		this.issues = frozenDiagnostics;
-	}
-};
-function entriesOf(input) {
-	if (Array.isArray(input)) return input;
-	return Object.entries(input);
-}
-function validLogicalId(id) {
-	return id.length > 0 && id === id.trim() && !/[.\\/\u0000-\u001f\u007f]/u.test(id);
-}
-function validNamespace(namespace) {
-	return namespace.length > 0 && namespace === namespace.trim() && !/[.\\/\u0000-\u001f\u007f"']/u.test(namespace);
-}
-function validateEntries(entries, namespace, namingPolicy) {
-	const diagnostics = [];
-	const ids = /* @__PURE__ */ new Map();
-	const physicalNames = /* @__PURE__ */ new Map();
-	const generatedNames = /* @__PURE__ */ new Map();
-	for (const [index, [id, table]] of entries.entries()) {
-		const path = ["tables", id];
-		const previousId = ids.get(id);
-		if (previousId !== void 0) diagnostics.push({
-			code: "duplicate-table-id",
-			message: `Table ID "${id}" is declared more than once`,
-			path,
-			relatedPaths: [["tables", entries[previousId][0]]]
-		});
-		else ids.set(id, index);
-		if (!validLogicalId(id)) diagnostics.push({
-			code: "invalid-table-id",
-			message: `Table ID "${id}" must be a non-empty logical identifier`,
-			path
-		});
-		const physicalName = table.tableName || namingPolicy.tableName(id);
-		const previousPhysicalName = physicalNames.get(physicalName);
-		if (previousPhysicalName !== void 0) diagnostics.push({
-			code: "duplicate-physical-name",
-			message: `Tables "${entries[previousPhysicalName][0]}" and "${id}" both use physical name "${physicalName}"`,
-			path: [...path, "physicalName"],
-			relatedPaths: [[
-				"tables",
-				entries[previousPhysicalName][0],
-				"physicalName"
-			]]
-		});
-		else physicalNames.set(physicalName, index);
-		const generatedName = namingPolicy.tableName(id);
-		const previousGeneratedName = generatedNames.get(generatedName);
-		if (previousGeneratedName !== void 0) diagnostics.push({
-			code: "generated-name-collision",
-			message: `Logical table IDs "${entries[previousGeneratedName][0]}" and "${id}" generate the same physical name "${generatedName}"`,
-			path: [...path, "generatedName"],
-			relatedPaths: [[
-				"tables",
-				entries[previousGeneratedName][0],
-				"generatedName"
-			]]
-		});
-		else generatedNames.set(generatedName, index);
-	}
-	if (namespace !== void 0 && !validNamespace(namespace)) diagnostics.push({
-		code: "invalid-namespace",
-		message: `Schema namespace "${namespace}" must be a non-empty identifier without qualification or control characters`,
-		path: ["namespace"]
-	});
-	return Object.freeze(diagnostics);
-}
-function freezeTableNames(entries, namingPolicy) {
-	return Object.freeze(Object.fromEntries(entries.map(([id, table]) => [id, table.tableName || namingPolicy.tableName(id)])));
-}
-function createSchema(entries, tables, options = {}) {
-	const namingPolicy = options.namingPolicy ?? defaultSchemaNamingPolicy;
-	const diagnostics = validateEntries(entries, options.namespace, namingPolicy);
-	if (diagnostics.length > 0) throw new SchemaValidationError(diagnostics);
-	const tableNames = freezeTableNames(entries, namingPolicy);
-	const registry = Object.freeze(Object.fromEntries(entries.map(([id, table]) => [id, Object.freeze({
-		id,
-		table,
-		physicalName: tableNames[id]
-	})])));
-	return Object.freeze({
-		schemaKind: "schema",
-		tables: Object.freeze({ ...tables }),
-		registry,
-		tableNames,
-		namespace: options.namespace,
-		namingPolicy: Object.freeze({ ...namingPolicy })
-	});
-}
-function schema(tables, options) {
-	const entries = entriesOf(tables);
-	return createSchema(entries, Object.fromEntries(entries), options);
-}
-/** Generate a v1 physical name for a logical table ID. */
-function generatedTableName(logicalId, namingPolicy = defaultSchemaNamingPolicy) {
-	return namingPolicy.tableName(logicalId);
-}
-//#endregion
-export { schemaNamingPolicyVersion as a, isUnsafeSchemaSql as c, renderSchemaSql as d, schemaExpression as f, schema as i, normalizeSchemaSql as l, defaultSchemaNamingPolicy as n, SchemaExpressionError as o, unsafeSchemaSql as p, generatedTableName as r, defineSchemaExpression as s, SchemaValidationError as t, renderSchemaExpression as u };

package/dist/serialize-CEIIlWhC.d.mts

@@ -1,66 +0,0 @@
-import { T as SnapshotJsonValue, Tr as SchemaDialect, Ur as Schema, f as SnapshotDiagnostic, i as SchemaSnapshotInput, l as SnapshotCreateResult, n as SchemaSnapshot, r as SchemaSnapshotAdapter, u as SnapshotDecodeResult } from "./types-C0VkiwpR.mjs";
-//#region src/snapshot/canonical.d.ts
-/** Error raised when a value cannot cross the canonical JSON boundary. */
-declare class SnapshotCanonicalError extends TypeError {
-  readonly path: readonly (string | number)[];
-  constructor(message: string, path?: readonly (string | number)[]);
-}
-/** Convert a JavaScript value to the explicit JSON-safe snapshot domain. */
-declare function toSnapshotJsonValue(value: unknown, path?: readonly (string | number)[], seen?: WeakSet<object>): SnapshotJsonValue;
-/** Render a JSON-safe value with deterministic scalar and object handling. */
-declare function canonicalJson(value: SnapshotJsonValue): string;
-/** Canonical JSON for a schema snapshot after fixed-order reconstruction. */
-declare function encodeCanonicalSnapshot(snapshot: SchemaSnapshot): string;
-/**
- * Compute a small deterministic content fingerprint for cache keys and diagnostics. It is
- * deliberately not an entity identity, signature, or migration lineage.
- */
-declare function schemaSnapshotFingerprint(snapshot: SchemaSnapshotInput | string): string;
-//#endregion
-//#region src/snapshot/decode.d.ts
-/** Error raised by throwing snapshot APIs after collecting diagnostics. */
-declare class SnapshotValidationError extends TypeError {
-  readonly name: string;
-  readonly diagnostics: readonly SnapshotDiagnostic[];
-  readonly issues: readonly SnapshotDiagnostic[];
-  constructor(diagnostics: readonly SnapshotDiagnostic[]);
-}
-/** Decode and strictly validate a JSON string or parsed snapshot value. */
-declare function decodeSchemaSnapshot(input: string | unknown): SnapshotDecodeResult;
-/** Validate a snapshot and throw one structured error if it is malformed. */
-declare function assertSchemaSnapshot(input: SchemaSnapshotInput | string): SchemaSnapshot;
-/** Return a fixed-order, deeply immutable copy of a valid snapshot. */
-declare function canonicalizeSchemaSnapshot(input: SchemaSnapshotInput): SchemaSnapshot;
-//#endregion
-//#region src/snapshot/serialize.d.ts
-/** Error raised when a live Qubu schema cannot be represented as a snapshot. */
-declare class SnapshotSerializationError extends SnapshotValidationError {
-  readonly name = "SnapshotSerializationError";
-}
-/** Options for the neutral traversal and a future dialect adapter. */
-interface SchemaSnapshotOptions {
-  readonly adapter?: SchemaSnapshotAdapter;
-  readonly dialect?: SchemaDialect;
-  /** Explicit hook overrides retained for custom tooling integrations. */
-  readonly expressionEncoder?: SchemaDialect["schema"]["encodeExpression"];
-  readonly storageEncoder?: SchemaDialect["schema"]["encodeStorage"];
-  readonly extensionEncoder?: SchemaDialect["schema"]["encodeDialectExtension"];
-  readonly namingPolicy?: {
-    readonly name: string;
-    readonly version?: number;
-  };
-}
-/** Create a neutral or adapter-owned immutable snapshot from a live schema. */
-declare function createSchemaSnapshot<TSchema extends Schema<any>>(schema: TSchema, options?: SchemaSnapshotOptions): SchemaSnapshot;
-/** Non-throwing form of {@link createSchemaSnapshot}. */
-declare function tryCreateSchemaSnapshot<TSchema extends Schema<any>>(schema: TSchema, options?: SchemaSnapshotOptions): SnapshotCreateResult;
-/** Encode a valid snapshot using fixed property order and canonical JSON. */
-declare function encodeSchemaSnapshot(snapshot: SchemaSnapshot): string;
-/** Alias used by tooling packages that call the operation serialization. */
-declare const serializeSchema: typeof createSchemaSnapshot;
-/** Alias for the canonical snapshot encoder. */
-declare const encodeSnapshot: typeof encodeSchemaSnapshot;
-/** Alias for the canonical snapshot fingerprint helper. */
-declare const fingerprintSchemaSnapshot: typeof schemaSnapshotFingerprint;
-//#endregion
-export { toSnapshotJsonValue as _, encodeSnapshot as a, tryCreateSchemaSnapshot as c, canonicalizeSchemaSnapshot as d, decodeSchemaSnapshot as f, schemaSnapshotFingerprint as g, encodeCanonicalSnapshot as h, encodeSchemaSnapshot as i, SnapshotValidationError as l, canonicalJson as m, SnapshotSerializationError as n, fingerprintSchemaSnapshot as o, SnapshotCanonicalError as p, createSchemaSnapshot as r, serializeSchema as s, SchemaSnapshotOptions as t, assertSchemaSnapshot as u };