@quereus/quereus 0.7.3 → 0.7.5

package/src/types/builtin-types.ts

@@ -1,350 +0,0 @@
-import { PhysicalType, type LogicalType } from './logical-type.js';
-
-/**
- * NULL type - represents null values
- */
-export const NULL_TYPE: LogicalType = {
-	name: 'NULL',
-	physicalType: PhysicalType.NULL,
-
-	validate: (v) => v === null,
-
-	compare: (a, b) => {
-		// Both must be null
-		if (a === null && b === null) return 0;
-		if (a === null) return -1;
-		if (b === null) return 1;
-		return 0;
-	},
-};
-
-/**
- * INTEGER type - whole numbers
- */
-export const INTEGER_TYPE: LogicalType = {
-	name: 'INTEGER',
-	physicalType: PhysicalType.INTEGER,
-	isNumeric: true,
-
-	validate: (v) => {
-		if (v === null) return true;
-		if (typeof v === 'bigint') return true;
-		if (typeof v === 'number') return Number.isInteger(v) && Number.isSafeInteger(v);
-		return false;
-	},
-
-	parse: (v) => {
-		if (v === null) return null;
-		if (typeof v === 'bigint') return v;
-		if (typeof v === 'number') {
-			if (!Number.isInteger(v)) {
-				return Math.trunc(v);
-			}
-			return v;
-		}
-		if (typeof v === 'boolean') return v ? 1 : 0;
-		if (typeof v === 'string') {
-			const trimmed = v.trim();
-			if (trimmed === '') return null;
-			const parsed = parseInt(trimmed, 10);
-			if (isNaN(parsed)) {
-				throw new TypeError(`Cannot convert '${v}' to INTEGER`);
-			}
-			return parsed;
-		}
-		throw new TypeError(`Cannot convert ${typeof v} to INTEGER`);
-	},
-
-	compare: (a, b) => {
-		if (a === null && b === null) return 0;
-		if (a === null) return -1;
-		if (b === null) return 1;
-
-		const numA = typeof a === 'bigint' ? Number(a) : a as number;
-		const numB = typeof b === 'bigint' ? Number(b) : b as number;
-
-		return numA < numB ? -1 : numA > numB ? 1 : 0;
-	},
-};
-
-/**
- * REAL type - floating point numbers
- */
-export const REAL_TYPE: LogicalType = {
-	name: 'REAL',
-	physicalType: PhysicalType.REAL,
-	isNumeric: true,
-
-	validate: (v) => {
-		if (v === null) return true;
-		return typeof v === 'number';
-	},
-
-	parse: (v) => {
-		if (v === null) return null;
-		if (typeof v === 'number') return v;
-		if (typeof v === 'bigint') return Number(v);
-		if (typeof v === 'boolean') return v ? 1.0 : 0.0;
-		if (typeof v === 'string') {
-			const trimmed = v.trim();
-			if (trimmed === '') return null;
-			const parsed = parseFloat(trimmed);
-			if (isNaN(parsed)) {
-				throw new TypeError(`Cannot convert '${v}' to REAL`);
-			}
-			return parsed;
-		}
-		throw new TypeError(`Cannot convert ${typeof v} to REAL`);
-	},
-
-	compare: (a, b) => {
-		if (a === null && b === null) return 0;
-		if (a === null) return -1;
-		if (b === null) return 1;
-
-		const numA = a as number;
-		const numB = b as number;
-
-		// Handle NaN
-		if (isNaN(numA) && isNaN(numB)) return 0;
-		if (isNaN(numA)) return -1;
-		if (isNaN(numB)) return 1;
-
-		return numA < numB ? -1 : numA > numB ? 1 : 0;
-	},
-};
-
-/**
- * TEXT type - strings
- */
-export const TEXT_TYPE: LogicalType = {
-	name: 'TEXT',
-	physicalType: PhysicalType.TEXT,
-	isTextual: true,
-	supportedCollations: ['BINARY', 'NOCASE', 'RTRIM'],
-
-	validate: (v) => {
-		if (v === null) return true;
-		return typeof v === 'string';
-	},
-
-	parse: (v) => {
-		if (v === null) return null;
-		if (typeof v === 'string') return v;
-		if (typeof v === 'number' || typeof v === 'bigint' || typeof v === 'boolean') {
-			return String(v);
-		}
-		if (v instanceof Uint8Array) {
-			// Convert blob to hex string
-			return Array.from(v)
-				.map(b => b.toString(16).padStart(2, '0'))
-				.join('');
-		}
-		throw new TypeError(`Cannot convert ${typeof v} to TEXT`);
-	},
-
-	compare: (a, b, collation) => {
-		if (a === null && b === null) return 0;
-		if (a === null) return -1;
-		if (b === null) return 1;
-
-		const strA = a as string;
-		const strB = b as string;
-
-		if (collation) {
-			return collation(strA, strB);
-		}
-
-		// Default binary comparison
-		return strA < strB ? -1 : strA > strB ? 1 : 0;
-	},
-};
-
-/**
- * BLOB type - binary data
- */
-export const BLOB_TYPE: LogicalType = {
-	name: 'BLOB',
-	physicalType: PhysicalType.BLOB,
-
-	validate: (v) => {
-		if (v === null) return true;
-		return v instanceof Uint8Array;
-	},
-
-	parse: (v) => {
-		if (v === null) return null;
-		if (v instanceof Uint8Array) return v;
-		if (typeof v === 'string') {
-			// Check if it's a hex string (even length, all hex chars)
-			if (v.length % 2 === 0 && /^[0-9a-fA-F]*$/.test(v) && v.length > 0) {
-				// Convert hex string to blob
-				const bytes = new Uint8Array(v.length / 2);
-				for (let i = 0; i < v.length; i += 2) {
-					bytes[i / 2] = parseInt(v.substr(i, 2), 16);
-				}
-				return bytes;
-			}
-			// For non-hex strings, convert to UTF-8 bytes
-			const encoder = new TextEncoder();
-			return encoder.encode(v);
-		}
-		if (typeof v === 'number' || typeof v === 'bigint' || typeof v === 'boolean') {
-			// Convert to string first, then to UTF-8 bytes
-			const encoder = new TextEncoder();
-			return encoder.encode(String(v));
-		}
-		throw new TypeError(`Cannot convert ${typeof v} to BLOB`);
-	},
-
-	compare: (a, b) => {
-		if (a === null && b === null) return 0;
-		if (a === null) return -1;
-		if (b === null) return 1;
-
-		const blobA = a as Uint8Array;
-		const blobB = b as Uint8Array;
-
-		const minLen = Math.min(blobA.length, blobB.length);
-		for (let i = 0; i < minLen; i++) {
-			if (blobA[i] !== blobB[i]) {
-				return blobA[i] < blobB[i] ? -1 : 1;
-			}
-		}
-
-		return blobA.length - blobB.length;
-	},
-};
-
-/**
- * BOOLEAN type - true/false values
- */
-export const BOOLEAN_TYPE: LogicalType = {
-	name: 'BOOLEAN',
-	physicalType: PhysicalType.BOOLEAN,
-
-	validate: (v) => {
-		if (v === null) return true;
-		return typeof v === 'boolean';
-	},
-
-	parse: (v) => {
-		if (v === null) return null;
-		if (typeof v === 'boolean') return v;
-		if (typeof v === 'number' || typeof v === 'bigint') {
-			return v !== 0;
-		}
-		if (typeof v === 'string') {
-			const lower = v.toLowerCase().trim();
-			if (lower === 'true' || lower === '1' || lower === 'yes' || lower === 'on') return true;
-			if (lower === 'false' || lower === '0' || lower === 'no' || lower === 'off') return false;
-			throw new TypeError(`Cannot convert '${v}' to BOOLEAN`);
-		}
-		throw new TypeError(`Cannot convert ${typeof v} to BOOLEAN`);
-	},
-
-	compare: (a, b) => {
-		if (a === null && b === null) return 0;
-		if (a === null) return -1;
-		if (b === null) return 1;
-
-		const boolA = a as boolean;
-		const boolB = b as boolean;
-
-		// false < true
-		if (boolA === boolB) return 0;
-		return boolA ? 1 : -1;
-	},
-};
-
-/**
- * NUMERIC type - for backward compatibility with SQLite's NUMERIC affinity
- * Tries to store as INTEGER if possible, otherwise REAL
- */
-export const NUMERIC_TYPE: LogicalType = {
-	name: 'NUMERIC',
-	physicalType: PhysicalType.REAL,
-	isNumeric: true,
-
-	validate: (v) => {
-		if (v === null) return true;
-		return typeof v === 'number' || typeof v === 'bigint';
-	},
-
-	parse: (v) => {
-		if (v === null) return null;
-		if (typeof v === 'number' || typeof v === 'bigint') return v;
-		if (typeof v === 'boolean') return v ? 1 : 0;
-		if (typeof v === 'string') {
-			const trimmed = v.trim();
-			if (trimmed === '') return null;
-
-			// Try integer first
-			if (/^-?\d+$/.test(trimmed)) {
-				const parsed = parseInt(trimmed, 10);
-				if (!isNaN(parsed)) return parsed;
-			}
-
-			// Fall back to real
-			const parsed = parseFloat(trimmed);
-			if (isNaN(parsed)) {
-				throw new TypeError(`Cannot convert '${v}' to NUMERIC`);
-			}
-			return parsed;
-		}
-		throw new TypeError(`Cannot convert ${typeof v} to NUMERIC`);
-	},
-
-	compare: (a, b) => {
-		// Use REAL comparison
-		return REAL_TYPE.compare!(a, b);
-	},
-};
-
-/**
- * ANY type - accepts any value without conversion
- * Useful for dynamic data or when type is truly unknown
- * Note: Uses NULL as physical type since it can represent any type
- */
-export const ANY_TYPE: LogicalType = {
-	name: 'ANY',
-	physicalType: PhysicalType.NULL,
-
-	validate: () => true, // Accept any value
-
-	parse: (v) => v, // No conversion, store as-is
-
-	compare: (a, b) => {
-		// Follow SQLite comparison rules: NULL < NUMERIC < TEXT < BLOB
-		if (a === null && b === null) return 0;
-		if (a === null) return -1;
-		if (b === null) return 1;
-
-		// Determine storage classes following SQLite rules
-		const getStorageClass = (v: any): number => {
-			const type = typeof v;
-			if (type === 'number' || type === 'bigint' || type === 'boolean') return 1; // NUMERIC
-			if (type === 'string') return 2; // TEXT
-			if (type === 'object' && v instanceof Uint8Array) return 3; // BLOB
-			return 4; // UNKNOWN
-		};
-
-		const classA = getStorageClass(a);
-		const classB = getStorageClass(b);
-
-		// Different storage classes: compare by class
-		if (classA !== classB) {
-			return classA < classB ? -1 : 1;
-		}
-
-		// Same storage class: compare values
-		// For booleans, convert to numbers (false=0, true=1)
-		const valA = typeof a === 'boolean' ? (a ? 1 : 0) : a;
-		const valB = typeof b === 'boolean' ? (b ? 1 : 0) : b;
-
-		if (valA < valB) return -1;
-		if (valA > valB) return 1;
-		return 0;
-	},
-};
-

package/src/types/index.ts

@@ -1,17 +0,0 @@
-// Core type system exports
-export { PhysicalType, type LogicalType, getPhysicalType, physicalTypeName } from './logical-type.js';
-
-// Built-in types
-export { NULL_TYPE, INTEGER_TYPE, REAL_TYPE, TEXT_TYPE, BLOB_TYPE, BOOLEAN_TYPE, NUMERIC_TYPE, ANY_TYPE } from './builtin-types.js';
-
-// Temporal types
-export { DATE_TYPE, TIME_TYPE, DATETIME_TYPE, TIMESPAN_TYPE } from './temporal-types.js';
-
-// JSON type
-export { JSON_TYPE } from './json-type.js';
-
-// Type registry
-export { typeRegistry, registerType, getType, getTypeOrDefault, inferType } from './registry.js';
-
-// Validation utilities
-export { validateValue, parseValue, validateAndParse, isValidForType, tryParse } from './validation.js';

package/src/types/json-type.ts

@@ -1,152 +0,0 @@
-import { PhysicalType, type LogicalType } from './logical-type.js';
-import { safeJsonParse } from '../func/builtins/json-helpers.js';
-
-/**
- * JSON type - stores valid JSON strings
- * Uses TEXT for physical storage but validates JSON syntax
- * Provides deep equality comparison for JSON values
- */
-export const JSON_TYPE: LogicalType = {
-	name: 'JSON',
-	physicalType: PhysicalType.TEXT,
-
-	validate: (v) => {
-		if (v === null) return true;
-		if (typeof v !== 'string') return false;
-		// Validate that it's valid JSON
-		return safeJsonParse(v) !== null;
-	},
-
-	parse: (v) => {
-		if (v === null) return null;
-		
-		// If it's already a string, validate and normalize it
-		if (typeof v === 'string') {
-			const parsed = safeJsonParse(v);
-			if (parsed === null) {
-				throw new TypeError(`Cannot convert '${v}' to JSON: invalid JSON syntax`);
-			}
-			// Normalize by re-stringifying (removes whitespace, ensures consistent format)
-			try {
-				return JSON.stringify(parsed);
-			} catch (e) {
-				throw new TypeError(`Cannot convert to JSON: ${e instanceof Error ? e.message : String(e)}`);
-			}
-		}
-
-		// Convert other types to JSON
-		if (typeof v === 'number' || typeof v === 'boolean') {
-			return JSON.stringify(v);
-		}
-
-		if (typeof v === 'bigint') {
-			// BigInt can't be directly serialized to JSON, convert to number
-			return JSON.stringify(Number(v));
-		}
-
-		throw new TypeError(`Cannot convert ${typeof v} to JSON`);
-	},
-
-	compare: (a, b) => {
-		// NULL handling
-		if (a === null && b === null) return 0;
-		if (a === null) return -1;
-		if (b === null) return 1;
-
-		// Both should be strings at this point
-		if (typeof a !== 'string' || typeof b !== 'string') {
-			// Fallback to string comparison
-			return String(a) < String(b) ? -1 : String(a) > String(b) ? 1 : 0;
-		}
-
-		// Parse both JSON values
-		const parsedA = safeJsonParse(a);
-		const parsedB = safeJsonParse(b);
-
-		// If either is invalid JSON, fall back to string comparison
-		if (parsedA === null || parsedB === null) {
-			return a < b ? -1 : a > b ? 1 : 0;
-		}
-
-		// Deep equality comparison
-		return deepCompareJson(parsedA, parsedB);
-	},
-
-	// No collations for JSON type
-	supportedCollations: [],
-
-	// Metadata
-	isNumeric: false,
-	isTextual: false,
-	isTemporal: false,
-};
-
-/**
- * Deep comparison of JSON values
- * Returns -1, 0, or 1 for ordering
- */
-function deepCompareJson(a: any, b: any): number {
-	// Same reference or both null/undefined
-	if (a === b) return 0;
-
-	// Type comparison first
-	const typeA = typeof a;
-	const typeB = typeof b;
-
-	if (typeA !== typeB) {
-		// Order: null < boolean < number < string < array < object
-		const typeOrder = { 
-			'object': a === null ? 0 : Array.isArray(a) ? 4 : 5,
-			'boolean': 1,
-			'number': 2,
-			'string': 3
-		};
-		const orderA = typeOrder[typeA as keyof typeof typeOrder] ?? 6;
-		const orderB = typeOrder[typeB as keyof typeof typeOrder] ?? 6;
-		return orderA < orderB ? -1 : 1;
-	}
-
-	// Same type comparison
-	if (a === null) return 0;
-
-	if (typeof a === 'boolean' || typeof a === 'number' || typeof a === 'string') {
-		return a < b ? -1 : a > b ? 1 : 0;
-	}
-
-	if (Array.isArray(a) && Array.isArray(b)) {
-		// Compare arrays element by element
-		const minLen = Math.min(a.length, b.length);
-		for (let i = 0; i < minLen; i++) {
-			const cmp = deepCompareJson(a[i], b[i]);
-			if (cmp !== 0) return cmp;
-		}
-		// If all elements are equal, shorter array comes first
-		return a.length < b.length ? -1 : a.length > b.length ? 1 : 0;
-	}
-
-	if (typeof a === 'object' && typeof b === 'object') {
-		// Compare objects by sorted keys
-		const keysA = Object.keys(a).sort();
-		const keysB = Object.keys(b).sort();
-
-		// Compare key sets first
-		const minKeys = Math.min(keysA.length, keysB.length);
-		for (let i = 0; i < minKeys; i++) {
-			if (keysA[i] < keysB[i]) return -1;
-			if (keysA[i] > keysB[i]) return 1;
-		}
-		if (keysA.length < keysB.length) return -1;
-		if (keysA.length > keysB.length) return 1;
-
-		// Keys are the same, compare values
-		for (const key of keysA) {
-			const cmp = deepCompareJson(a[key], b[key]);
-			if (cmp !== 0) return cmp;
-		}
-		return 0;
-	}
-
-	// Fallback
-	return 0;
-}
-

package/src/types/logical-type.ts

@@ -1,91 +0,0 @@
-import type { SqlValue } from '../common/types.js';
-
-/**
- * Function type for SQLite collation functions.
- * Takes two strings and returns a comparison result (-1, 0, 1)
- */
-export type CollationFunction = (a: string, b: string) => number;
-
-/**
- * Physical types represent how values are stored in memory and on disk.
- * These are the actual runtime representations.
- */
-export enum PhysicalType {
-	NULL = 0,
-	INTEGER = 1,    // number | bigint
-	REAL = 2,       // number (floating point)
-	TEXT = 3,       // string
-	BLOB = 4,       // Uint8Array
-	BOOLEAN = 5,    // boolean
-}
-
-/**
- * Logical types define the semantics and behavior of values.
- * They specify validation, comparison, and conversion rules.
- */
-export interface LogicalType {
-	// Identity
-	/** Type name (e.g., "DATE", "INTEGER", "TEXT") */
-	name: string;
-	/** Physical storage representation */
-	physicalType: PhysicalType;
-
-	// Validation
-	/** Check if value is valid for this type */
-	validate?(value: SqlValue): boolean;
-	/** Convert/normalize value to canonical form */
-	parse?(value: SqlValue): SqlValue;
-
-	// Comparison
-	/** Type-specific comparison function */
-	compare?(a: SqlValue, b: SqlValue, collation?: CollationFunction): number;
-	/** Which collations apply to this type */
-	supportedCollations?: readonly string[];
-
-	// Serialization
-	/** Convert for storage/export */
-	serialize?(value: SqlValue): SqlValue;
-	/** Convert from storage */
-	deserialize?(value: SqlValue): SqlValue;
-
-	// Metadata
-	/** Is this a numeric type? */
-	isNumeric?: boolean;
-	/** Is this a textual type? */
-	isTextual?: boolean;
-	/** Is this a temporal type? */
-	isTemporal?: boolean;
-}
-
-/**
- * Get the physical type of a SqlValue at runtime.
- * This is used for values that don't have an associated logical type.
- */
-export function getPhysicalType(value: SqlValue): PhysicalType {
-	if (value === null) return PhysicalType.NULL;
-	if (typeof value === 'number') {
-		return Number.isInteger(value) ? PhysicalType.INTEGER : PhysicalType.REAL;
-	}
-	if (typeof value === 'bigint') return PhysicalType.INTEGER;
-	if (typeof value === 'string') return PhysicalType.TEXT;
-	if (typeof value === 'boolean') return PhysicalType.BOOLEAN;
-	if (value instanceof Uint8Array) return PhysicalType.BLOB;
-	return PhysicalType.NULL;
-}
-
-/**
- * Get a human-readable name for a physical type code.
- * Useful for error messages and debugging.
- */
-export function physicalTypeName(physicalType: PhysicalType): string {
-	switch (physicalType) {
-		case PhysicalType.NULL: return 'NULL';
-		case PhysicalType.INTEGER: return 'INTEGER';
-		case PhysicalType.REAL: return 'REAL';
-		case PhysicalType.TEXT: return 'TEXT';
-		case PhysicalType.BLOB: return 'BLOB';
-		case PhysicalType.BOOLEAN: return 'BOOLEAN';
-		default: return 'UNKNOWN';
-	}
-}
-

package/src/types/plugin-interface.ts

@@ -1,10 +0,0 @@
-import type { LogicalType } from './logical-type.js';
-
-/**
- * Type plugin registration info
- */
-export interface TypePluginInfo {
-	name: string;                  // Type name for registration
-	definition: LogicalType;       // The LogicalType implementation
-}
-