@bjornpagen/bumbledb 1.3.1 → 2.0.0

package/src/lower.ts

@@ -1,122 +1,111 @@
-import { AuthoringError } from "#errors.ts"
 /**
- * Descriptor lowering: SDK values down to the PRD-01 `SchemaSpec` plain
- * data (`#spec.ts`), which the napi bridge marshals verbatim. Lowering is
- * TOTAL on well-typed inputs — no validation lives here beyond what the
- * types and the construction boundaries already guarantee — and it is the
- * only place statement internals are read for the wire. In particular,
- * lowering never emits an engine-refused containment target: it accepts
- * only `schema` outputs, and `schema`'s target-key wall already
- * refused any non-key target projection (60-containment-parity —
- * totality INHERITED, not re-checked). Ordering is declaration order
- * throughout, and every output object is built with one fixed key order,
- * so serialization is deterministic (byte-stable).
+ * Lowers a schema to the addon's `SchemaSpecIn`, in declaration order with a fixed key order, so
+ * the JSON is byte-stable. Lowering judges nothing: the engine compiles and judges the spec.
  */
-
-import type { AnyClosed } from "#closed.ts"
-import { isClosedMember } from "#closed.ts"
-import type { AnyFace } from "#face.ts"
-import { type AnyField, literalOf } from "#fields.ts"
-import type { RelationClasses } from "#law.ts"
-import { type AnyRelation, relationFields } from "#relation.ts"
-import type { AnySchema } from "#schema.ts"
+import type { AnyClosed } from "./closed.ts"
+import { isClosedMember } from "./closed.ts"
+import { AuthoringError } from "./errors.ts"
+import type { AnyFace } from "./face.ts"
+import { type AnyField, literalOf } from "./fields.ts"
+import type { RelationClasses } from "./law.ts"
 import type {
-	FieldSpec,
-	LiteralSetSpec,
-	RelationSpec,
-	SchemaSpec,
-	SideSpec,
-	StatementSpec,
-	ValueTypeSpec
-} from "#spec.ts"
-import type { Statement } from "#statements.ts"
+	FieldSpecIn,
+	RelationSpecIn,
+	SchemaSpecIn,
+	SideSpecIn,
+	StatementSpecIn,
+	ValueTypeIn
+} from "./native/binding.d.ts"
+import { literalIn, literalSetIn, weightIn, windowIn } from "./native/json.ts"
+import { type AnyRelation, relationFields } from "./relation.ts"
+import type { AnySchema } from "./schema.ts"
+import type { Statement } from "./statements.ts"
+
+const ELEMENT = { u64: "U64", i64: "I64", f64: "F64" } as const
 
-function valueTypeOf(field: AnyField): ValueTypeSpec {
+function valueTypeOf(field: AnyField): ValueTypeIn {
 	switch (field.kind) {
 		case "bool":
-			return { kind: "bool" }
+			return { kind: "Bool" }
 		case "u64":
-			return { kind: "u64" }
+			return { kind: "U64" }
 		case "i64":
-			return { kind: "i64" }
+			return { kind: "I64" }
 		case "f64":
-			return { kind: "f64" }
+			return { kind: "F64" }
 		case "uuid":
-			return { kind: "uuid" }
+			return { kind: "Uuid" }
 		case "str":
-			return { kind: "string" }
+			return { kind: "String" }
 		case "bytes":
-			return { kind: "fixedBytes", len: field.width }
+			return { kind: "FixedBytes", len: field.width }
 		case "interval":
-			return { kind: "interval", element: field.element, width: field.width }
+			if (field.width === undefined) return { kind: "Interval", element: ELEMENT[field.element] }
+			if (field.element === "f64")
+				throw new AuthoringError({ message: "a fixed-width interval needs an integer element" })
+			return { kind: "FixedInterval", element: ELEMENT[field.element], width: field.width.toString() }
 	}
 }
 
-function lowerField(name: string, field: AnyField, newtype: string | undefined): FieldSpec {
-	return {
-		name,
-		valueType: valueTypeOf(field),
-		newtype
-	}
+function lowerField(name: string, field: AnyField, newtype: string | undefined): FieldSpecIn {
+	return newtype === undefined
+		? { name, valueType: valueTypeOf(field) }
+		: { name, valueType: valueTypeOf(field), newtype }
 }
 
-function lowerFace(face: AnyFace): SideSpec {
+function lowerFace(face: AnyFace): SideSpecIn {
 	return {
 		relation: face.owner.name,
 		projection: [...face.projection],
-		selection: face.selection.map(function lowerBinding(binding): readonly [string, LiteralSetSpec] {
-			return [binding.field, binding.set]
-		})
+		selection: face.selection.map((binding) => ({ field: binding.field, set: literalSetIn(binding.set) }))
 	}
 }
 
-function lowerStatement(statement: Statement): StatementSpec {
+function lowerStatement(statement: Statement): StatementSpecIn {
 	const data = statement
 	switch (data.kind) {
 		case "key":
-			return { kind: "fd", relation: data.owner.name, projection: [...data.projection] }
+			return { kind: "Fd", relation: data.owner.name, projection: [...data.projection] }
 		case "containment":
 			return {
-				kind: "containment",
+				kind: "Containment",
 				source: lowerFace(data.source),
 				target: lowerFace(data.target),
 				bidirectional: false
 			}
 		case "mirrors":
 			return {
-				kind: "containment",
+				kind: "Containment",
 				source: lowerFace(data.source),
 				target: lowerFace(data.target),
 				bidirectional: true
 			}
 		case "capacity":
 			return {
-				kind: "capacity",
+				kind: "Capacity",
 				target: lowerFace(data.target),
-				weight: data.weight,
-				window: data.window,
+				weight: weightIn(data.weight),
+				window: windowIn(data.window),
 				source: lowerFace(data.source)
 			}
 	}
 }
 
-function lowerRelation(relation: AnyRelation, classes: RelationClasses): RelationSpec {
-	const fields: FieldSpec[] = relationFields(relation).map(function lowerDeclared(declared) {
-		return lowerField(declared.name, declared.field, classes[declared.name])
-	})
-	return { name: relation.name, fields, closed: undefined }
+function lowerRelation(relation: AnyRelation, classes: RelationClasses): RelationSpecIn {
+	const fields = relationFields(relation).map((declared) =>
+		lowerField(declared.name, declared.field, classes[declared.name])
+	)
+	return { name: relation.name, fields }
 }
 
-function lowerClosed(member: AnyClosed, classes: RelationClasses): RelationSpec {
-	const fields: FieldSpec[] = Object.entries(member.columns).map(function lowerColumn([name, field]) {
-		return lowerField(name, field, classes[name])
-	})
-	const rows = member.handles.map(function lowerRow(handle) {
-		return {
-			handle,
-			values: Object.entries(member.columns).map(([name, field]) => literalOf(field, member.axioms[handle]?.[name]))
-		}
-	})
+function lowerClosed(member: AnyClosed, classes: RelationClasses): RelationSpecIn {
+	const fields = Object.entries(member.columns).map(([name, field]) => lowerField(name, field, classes[name]))
+	const rows = member.handles.map((handle) => ({
+		handle,
+		values: Object.entries(member.columns).map(([name, field]) =>
+			literalIn(literalOf(field, member.axioms[handle]?.[name]))
+		)
+	}))
 	const newtype = classes.id
 	if (newtype === undefined) {
 		throw new AuthoringError({
@@ -128,8 +117,8 @@ function lowerClosed(member: AnyClosed, classes: RelationClasses): RelationSpec
 
 const noClasses: RelationClasses = Object.freeze({})
 
-function lower(theory: AnySchema): SchemaSpec {
-	const relations: RelationSpec[] = Object.entries(theory.relations).map(function lowerMember([name, member]) {
+function lower(theory: AnySchema): SchemaSpecIn {
+	const relations: RelationSpecIn[] = Object.entries(theory.relations).map(function lowerMember([name, member]) {
 		const classes = theory.classes[name] ?? noClasses
 		if (isClosedMember(member)) {
 			return lowerClosed(member, classes)

package/src/native/addon.ts

@@ -0,0 +1,54 @@
+import type * as Binding from "./binding.d.ts"
+import { loadAddon } from "./load.ts"
+
+/** The addon's exports, typed by the bridge's generated declarations. */
+type Addon = typeof Binding
+
+type External<T> = Binding.ExternalObject<T>
+type RuntimeRef = External<Binding.RuntimeHandle>
+type OperationRef = External<Binding.OperationHandle>
+type DirectoryRef = External<Binding.DirectoryHandle>
+type DbRef = External<Binding.DbHandle>
+type SchemaRef = External<Binding.SchemaHandle>
+type QueryRef = External<Binding.QueryHandle>
+type SnapshotRef = External<Binding.SnapshotHandle>
+type PreparedRef = External<Binding.PreparedHandle>
+type ResultRef = External<Binding.ResultHandle>
+type CursorRef = External<Binding.CursorHandle>
+type DraftRef = External<Binding.DraftHandle>
+type ChangesRef = External<Binding.ChangesHandle>
+type ChangesCursorRef = External<Binding.ChangesCursorHandle>
+type WitnessRef = External<Binding.WitnessHandle>
+
+let loaded: Addon | undefined
+
+/** The addon, loaded on first use rather than at import. */
+const addon: Addon = new Proxy({} as Addon, {
+	get(_target, property) {
+		loaded ??= loadAddon<Addon>(process.platform, process.arch)
+		return Reflect.get(loaded, property)
+	},
+	set(_target, property, value) {
+		loaded ??= loadAddon<Addon>(process.platform, process.arch)
+		return Reflect.set(loaded, property, value)
+	}
+})
+
+export type {
+	Addon,
+	ChangesCursorRef,
+	ChangesRef,
+	CursorRef,
+	DbRef,
+	DirectoryRef,
+	DraftRef,
+	OperationRef,
+	PreparedRef,
+	QueryRef,
+	ResultRef,
+	RuntimeRef,
+	SchemaRef,
+	SnapshotRef,
+	WitnessRef
+}
+export { addon }