const std = @import("std"); const json_read = @import("../json/read.zig"); const sql_strings = @import("../sql/build.zig"); const schema_constraints = @import("constraints.zig"); const field_path = @import("field_path.zig"); const index = @import("index.zig"); const system = @import("system.zig"); const types = @import("types.zig"); const Version = @import("version.zig").Version; const Allocator = std.mem.Allocator; const constraint_keys = [_][]const u8{ "enum", "pattern", "format", "minLength", "maxLength", "minimum", "maximum", }; const store_field_keys = [_][]const u8{ "type", "indexed", "references", "onDelete", "items", "fields", "metadata", } ++ constraint_keys; const presence_leaf_field_keys = [_][]const u8{"type"} ++ constraint_keys; fn cloneMetadata(allocator: Allocator, value: std.json.Value) !types.Metadata { if (value != .object) return error.InvalidMetadata; return .{ .json = try std.json.Stringify.valueAlloc(allocator, value, .{}) }; } pub fn initFromJson(allocator: Allocator, json_text: []const u8) !types.Schema { var parsed = try json_read.parseValue(allocator, json_text); defer parsed.deinit(); const root = parsed.value; if (root != .object) return error.InvalidSchema; try json_read.rejectUnknownKeys(error.UnknownSchemaKey, &.{ "version", "store", "metadata", "presence", "actions" }, root.object); const version_val = (json_read.getString(root.object, "version") catch return error.InvalidVersion) orelse return error.MissingVersion; const store_val = (json_read.getObject(root.object, "store") catch return error.InvalidStore) orelse return error.MissingStore; const root_metadata = if (root.object.get("metadata")) |metadata| try cloneMetadata(allocator, metadata) else null; defer if (root_metadata) |metadata| metadata.deinit(allocator); var declared_tables = std.ArrayListUnmanaged(types.Table).empty; defer { for (declared_tables.items) |*table| table.deinit(allocator); declared_tables.deinit(allocator); } try collectTables(allocator, store_val, &declared_tables); // Parse presence block if exists, else synthesize implicit minimal schema var presence_user_fields = std.ArrayListUnmanaged(types.PresenceField).empty; var presence_shared_fields = std.ArrayListUnmanaged(types.PresenceField).empty; defer { for (presence_user_fields.items) |f| f.deinit(allocator); presence_user_fields.deinit(allocator); for (presence_shared_fields.items) |f| f.deinit(allocator); presence_shared_fields.deinit(allocator); } try collectPresenceFields(allocator, root.object, &presence_user_fields, &presence_shared_fields); // Build name arrays for presence fields var user_names = std.ArrayListUnmanaged([]const u8).empty; defer user_names.deinit(allocator); try user_names.ensureTotalCapacityPrecise(allocator, presence_user_fields.items.len); for (presence_user_fields.items) |f| user_names.appendAssumeCapacity(f.name); var shared_names = std.ArrayListUnmanaged([]const u8).empty; defer shared_names.deinit(allocator); try shared_names.ensureTotalCapacityPrecise(allocator, presence_shared_fields.items.len); for (presence_shared_fields.items) |f| shared_names.appendAssumeCapacity(f.name); var actions = std.ArrayListUnmanaged(types.Action).empty; defer { for (actions.items) |*action| action.deinit(allocator); actions.deinit(allocator); } try collectActions(allocator, root.object, &actions); return initFromTables( allocator, version_val, root_metadata, declared_tables.items, actions.items, presence_user_fields.items, presence_shared_fields.items, user_names.items, shared_names.items, ); } fn collectTables( allocator: Allocator, store_obj: std.json.ObjectMap, declared_tables: *std.ArrayListUnmanaged(types.Table), ) !void { // Users table first — explicit or implicit if (store_obj.get("users")) |users_def| { var table = try parseTable(allocator, "users", users_def, true); var appended = false; errdefer if (!appended) table.deinit(allocator); try declared_tables.append(allocator, table); appended = true; } else { var table = try implicitUsersTable(allocator); var appended = false; errdefer if (!appended) table.deinit(allocator); try declared_tables.append(allocator, table); appended = true; } // Remaining store tables var store_iter = store_obj.iterator(); while (store_iter.next()) |entry| { const table_name = entry.key_ptr.*; if (std.mem.eql(u8, table_name, "users")) continue; var table = try parseTable(allocator, table_name, entry.value_ptr.*, false); var appended = false; errdefer if (!appended) table.deinit(allocator); try declared_tables.append(allocator, table); appended = true; } } fn collectPresenceFields( allocator: Allocator, root_obj: std.json.ObjectMap, presence_user_fields: *std.ArrayListUnmanaged(types.PresenceField), presence_shared_fields: *std.ArrayListUnmanaged(types.PresenceField), ) !void { if (root_obj.get("presence")) |presence_val| { if (presence_val != .object) return error.InvalidSchema; const po = presence_val.object; try json_read.rejectUnknownKeys(error.UnknownSchemaKey, &.{ "user", "shared" }, po); if (po.get("user")) |user_val| { try parsePresenceTier(allocator, user_val, presence_user_fields); } if (po.get("shared")) |shared_val| { try parsePresenceTier(allocator, shared_val, presence_shared_fields); } } else { // Synthesize implicit minimal schema: user.status: string const status_name = try allocator.dupe(u8, "status"); errdefer allocator.free(status_name); try presence_user_fields.append(allocator, .{ .name = status_name, .declared_type = .text, }); } } const max_presence_fields: usize = 500; pub const max_store_fields: usize = 1024; fn parsePresenceTier( allocator: Allocator, tier_val: std.json.Value, fields_list: *std.ArrayListUnmanaged(types.PresenceField), ) !void { if (tier_val != .object) return error.InvalidSchema; var ctx = PresenceFieldContext{ .fields_list = fields_list }; try parseObjectFields(allocator, tier_val.object, "", PresenceFieldContext, &ctx); } pub const max_action_fields: usize = 500; const action_keys = [_][]const u8{ "params", "required", "returns", "scope", "claims" }; const action_leaf_field_keys = [_][]const u8{ "type", "items" } ++ constraint_keys; fn collectActions( allocator: Allocator, root_obj: std.json.ObjectMap, actions: *std.ArrayListUnmanaged(types.Action), ) !void { const actions_val = root_obj.get("actions") orelse return; if (actions_val != .object) return error.InvalidSchema; var it = actions_val.object.iterator(); while (it.next()) |entry| { var action = try parseAction(allocator, entry.key_ptr.*, entry.value_ptr.*); var appended = false; errdefer if (!appended) action.deinit(allocator); try actions.append(allocator, action); appended = true; } } fn parseActionScope(scope_val: ?std.json.Value) !types.ActionScope { const val = scope_val orelse return .store; if (val != .string) return error.InvalidActionScope; if (std.mem.eql(u8, val.string, "store")) return .store; if (std.mem.eql(u8, val.string, "presence")) return .presence; return error.InvalidActionScope; } /// Session variable names projected into the worker's `ActionContext.claims`. /// Not validated against `authentication.session.claims`: an unmapped name /// simply never resolves at forward time. fn parseActionClaims(allocator: Allocator, claims_val: ?std.json.Value) ![]const []const u8 { const val = claims_val orelse return &.{}; if (val != .array) return error.InvalidActionClaims; var claims = std.ArrayListUnmanaged([]const u8).empty; errdefer { for (claims.items) |s| allocator.free(s); claims.deinit(allocator); } // `claims` preserves insertion order for the owned slice; `seen` only // answers "already present" so dedup stays linear. Keys borrow the JSON // tree, which outlives this function's maps. var seen = std.StringHashMapUnmanaged(void){}; defer seen.deinit(allocator); for (val.array.items) |item| { if (item != .string) return error.InvalidActionClaims; if (item.string.len == 0) return error.InvalidActionClaims; const gop = try seen.getOrPut(allocator, item.string); if (gop.found_existing) return error.InvalidActionClaims; // Transfer ownership to `claims` only after the append succeeds so an // OOM failure cannot leak the duplicate. const duped = try allocator.dupe(u8, item.string); errdefer allocator.free(duped); try claims.append(allocator, duped); } return claims.toOwnedSlice(allocator); } fn parseActionRequiredSet(allocator: Allocator, action_obj: std.json.ObjectMap) !std.StringHashMap(bool) { var required_set = std.StringHashMap(bool).init(allocator); errdefer deinitRequiredSet(allocator, &required_set); const required = (json_read.getArray(action_obj, "required") catch return error.InvalidActionDefinition) orelse return required_set; for (required.items) |item| { if (item != .string) return error.InvalidActionDefinition; const normalized = try field_path.normalizeDots(allocator, item.string); errdefer allocator.free(normalized); const gop = try required_set.getOrPut(normalized); if (gop.found_existing) { allocator.free(normalized); } else { gop.value_ptr.* = false; } } return required_set; } fn parseActionFields( allocator: Allocator, fields_val: std.json.Value, required_set: *std.StringHashMap(bool), force_required: bool, ) ![]const types.ActionField { if (fields_val != .object) return error.InvalidActionDefinition; var fields = std.ArrayListUnmanaged(types.ActionField).empty; errdefer { for (fields.items) |f| f.deinit(allocator); fields.deinit(allocator); } var ctx = ActionFieldContext{ .fields = &fields, .required_set = required_set, .force_required = force_required, }; try parseObjectFields(allocator, fields_val.object, "", ActionFieldContext, &ctx); return fields.toOwnedSlice(allocator); } fn parseAction(allocator: Allocator, action_name_raw: []const u8, action_def: std.json.Value) !types.Action { if (!isValidTableIdentifier(action_name_raw)) return error.InvalidActionName; if (action_def != .object) return error.InvalidActionDefinition; try json_read.rejectUnknownKeys(error.UnknownSchemaKey, &action_keys, action_def.object); const name = try allocator.dupe(u8, action_name_raw); errdefer allocator.free(name); const scope = try parseActionScope(action_def.object.get("scope")); const claims = try parseActionClaims(allocator, action_def.object.get("claims")); errdefer types.deinitStringSlice(claims, allocator); var required_set = try parseActionRequiredSet(allocator, action_def.object); defer deinitRequiredSet(allocator, &required_set); const params = if (action_def.object.get("params")) |params_val| try parseActionFields(allocator, params_val, &required_set, false) else &[_]types.ActionField{}; errdefer { for (params) |f| f.deinit(allocator); allocator.free(params); } try ensureRequiredFieldsResolved(&required_set); // Every declared return field must be present in a successful reply. const returns: ?[]const types.ActionField = if (action_def.object.get("returns")) |returns_val| blk: { if (returns_val == .null) break :blk null; if (returns_val != .object) return error.InvalidActionReturns; var empty_required = std.StringHashMap(bool).init(allocator); defer empty_required.deinit(); break :blk try parseActionFields(allocator, returns_val, &empty_required, true); } else null; errdefer if (returns) |fields| { for (fields) |f| f.deinit(allocator); allocator.free(fields); }; return .{ .name = name, .scope = scope, .params = params, .returns = returns, .claims = claims, }; } /// Context for action params/returns parsing. Allowed keys exclude every /// store-only property, so `indexed`, `references`, `onDelete`, `unique`, /// and `metadata` are rejected as unknown schema keys. const ActionFieldContext = struct { fields: *std.ArrayListUnmanaged(types.ActionField), required_set: *std.StringHashMap(bool), force_required: bool, fn preValidate(_: *@This(), _: []const u8, type_str: []const u8, def: std.json.Value) !void { if (std.mem.eql(u8, type_str, "object")) { try json_read.rejectUnknownKeys(error.UnknownSchemaKey, &.{ "type", "fields" }, def.object); } else { try json_read.rejectUnknownKeys(error.UnknownSchemaKey, &action_leaf_field_keys, def.object); } } fn preObjectValidate(ctx: *@This(), full_name: []const u8) !void { if (!ctx.force_required and ctx.required_set.contains(full_name)) return error.InvalidRequiredField; } fn fieldType(type_str: []const u8) !types.FieldType { return field_type_map.get(type_str) orelse error.UnknownFieldType; } fn emitField(ctx: *@This(), allocator: Allocator, full_name: []const u8, declared_type: types.FieldType, field_def: std.json.Value) !void { if (ctx.fields.items.len >= max_action_fields) return error.TooManyActionFields; var required = ctx.force_required; if (ctx.required_set.getPtr(full_name)) |seen| { seen.* = true; required = true; } const items_type = try extractArrayItemsType(declared_type, field_def); const constraints = try parseConstraints(allocator, declared_type, field_def.object); errdefer if (constraints) |c| c.deinit(allocator); try ctx.fields.append(allocator, .{ .name = full_name, .declared_type = declared_type, .items_type = items_type, .required = required, .constraints = constraints, }); } }; fn hasConstraintKeys(field_obj: std.json.ObjectMap) bool { for (constraint_keys) |key| { if (field_obj.contains(key)) return true; } return false; } /// Shared recursive object-field parser. Flattens nested objects using `__` prefix. /// Parameterized via comptime Ctx for store vs presence field logic. fn parseObjectFields( allocator: Allocator, fields_value: std.json.ObjectMap, prefix: []const u8, comptime Ctx: type, ctx: *Ctx, ) !void { var it = fields_value.iterator(); while (it.next()) |entry| { const field_name = entry.key_ptr.*; const field_def = entry.value_ptr.*; if (!isValidFieldIdentifier(field_name)) return error.InvalidFieldName; if (field_def != .object) return error.InvalidFieldDefinition; const type_value = (json_read.getString(field_def.object, "type") catch return error.InvalidFieldType) orelse return error.MissingFieldType; try ctx.preValidate(field_name, type_value, field_def); const full_name = try field_path.join(allocator, prefix, field_name); errdefer allocator.free(full_name); if (std.mem.eql(u8, type_value, "object")) { if (hasConstraintKeys(field_def.object)) { return error.InvalidConstraint; } try ctx.preObjectValidate(full_name); const nested_fields = (json_read.getObject(field_def.object, "fields") catch return error.InvalidSchema) orelse return error.MissingFields; try parseObjectFields(allocator, nested_fields, full_name, Ctx, ctx); allocator.free(full_name); } else { const declared_type = try Ctx.fieldType(type_value); try ctx.emitField(allocator, full_name, declared_type, field_def); } } } fn hasAnyKey(object: std.json.ObjectMap, keys: []const []const u8) bool { for (keys) |key| { if (object.contains(key)) return true; } return false; } fn validateConstraintApplicability(declared_type: types.FieldType, field_obj: std.json.ObjectMap) !void { switch (declared_type) { .text => if (hasAnyKey(field_obj, &.{ "minimum", "maximum" })) return error.InvalidConstraint, .integer, .real => if (hasAnyKey(field_obj, &.{ "pattern", "format", "minLength", "maxLength" })) return error.InvalidConstraint, .bytes => if (hasAnyKey(field_obj, &.{ "pattern", "format", "enum", "minimum", "maximum" })) return error.InvalidConstraint, else => return error.InvalidConstraint, } } fn parseEnumValue(allocator: Allocator, declared_type: types.FieldType, item: std.json.Value) !types.Constraints.EnumValue { return switch (declared_type) { .text => if (item == .string) .{ .text = try allocator.dupe(u8, item.string) } else error.InvalidConstraint, .integer => if (item == .integer) .{ .integer = item.integer } else error.InvalidConstraint, .real => .{ .real = switch (item) { .float => |f| f, .integer => |i| @floatFromInt(i), else => return error.InvalidConstraint, } }, else => error.InvalidConstraint, }; } fn parseEnumConstraint(allocator: Allocator, declared_type: types.FieldType, value: ?std.json.Value) !?[]const types.Constraints.EnumValue { const enum_val = value orelse return null; if (enum_val != .array or enum_val.array.items.len == 0) return error.InvalidConstraint; const list = try allocator.alloc(types.Constraints.EnumValue, enum_val.array.items.len); var built: usize = 0; errdefer { for (list[0..built]) |item| item.deinit(allocator); allocator.free(list); } for (enum_val.array.items) |item| { list[built] = try parseEnumValue(allocator, declared_type, item); built += 1; } return list; } const ParsedPattern = struct { source: []const u8, compiled: *anyopaque, }; fn parsePatternConstraint(allocator: Allocator, value: ?std.json.Value) !?ParsedPattern { const pattern_val = value orelse return null; if (pattern_val != .string or pattern_val.string.len == 0 or std.mem.indexOfScalar(u8, pattern_val.string, 0) != null) return error.InvalidConstraint; const compiled = schema_constraints.compilePattern(allocator, pattern_val.string) catch return error.InvalidConstraint; errdefer schema_constraints.freePattern(allocator, compiled); return .{ .source = try allocator.dupe(u8, pattern_val.string), .compiled = compiled, }; } fn parseFormatConstraint(value: ?std.json.Value) !?types.Constraints.Format { const format_val = value orelse return null; if (format_val != .string) return error.InvalidConstraint; return types.Constraints.Format.fromString(format_val.string) orelse error.InvalidConstraint; } fn parseLengthConstraint(value: ?std.json.Value) !?u64 { const length_val = value orelse return null; if (length_val != .integer or length_val.integer < 0) return error.InvalidConstraint; return @intCast(length_val.integer); } fn parseIntegerBound(value: std.json.Value) !i64 { return switch (value) { .integer => |integer| integer, .float => |float| blk: { if (std.math.isNan(float) or std.math.isInf(float)) return error.InvalidConstraint; if (float != @trunc(float)) return error.InvalidConstraint; const min_i64_float: f64 = @floatFromInt(std.math.minInt(i64)); const max_i64_exclusive = -min_i64_float; if (float < min_i64_float or float >= max_i64_exclusive) return error.InvalidConstraint; break :blk @intFromFloat(float); }, else => error.InvalidConstraint, }; } fn parseRealBound(value: std.json.Value) !f64 { const result: f64 = switch (value) { .float => |float| float, .integer => |integer| @floatFromInt(integer), else => return error.InvalidConstraint, }; if (std.math.isNan(result) or std.math.isInf(result)) return error.InvalidConstraint; return result; } fn parseBound(declared_type: types.FieldType, value: ?std.json.Value) !?types.Constraints.Bound { const bound = value orelse return null; return switch (declared_type) { .integer => .{ .integer = try parseIntegerBound(bound) }, .real => .{ .real = try parseRealBound(bound) }, else => error.InvalidConstraint, }; } fn validateConstraintOrder(declared_type: types.FieldType, constraints: types.Constraints) !void { if (constraints.min_length != null and constraints.max_length != null and constraints.min_length.? > constraints.max_length.?) { return error.InvalidConstraint; } if (constraints.minimum == null or constraints.maximum == null) return; switch (declared_type) { .integer => if (constraints.minimum.?.integer > constraints.maximum.?.integer) return error.InvalidConstraint, .real => if (constraints.minimum.?.real > constraints.maximum.?.real) return error.InvalidConstraint, else => return error.InvalidConstraint, } } fn parseConstraints(allocator: Allocator, declared_type: types.FieldType, field_obj: std.json.ObjectMap) !?types.Constraints { if (!hasConstraintKeys(field_obj)) return null; try validateConstraintApplicability(declared_type, field_obj); var constraints: types.Constraints = .{}; errdefer constraints.deinit(allocator); constraints.enum_values = try parseEnumConstraint(allocator, declared_type, field_obj.get("enum")); if (try parsePatternConstraint(allocator, field_obj.get("pattern"))) |pattern| { constraints.pattern_source = pattern.source; constraints.compiled_regex = pattern.compiled; } constraints.format = try parseFormatConstraint(field_obj.get("format")); constraints.min_length = try parseLengthConstraint(field_obj.get("minLength")); constraints.max_length = try parseLengthConstraint(field_obj.get("maxLength")); constraints.minimum = try parseBound(declared_type, field_obj.get("minimum")); constraints.maximum = try parseBound(declared_type, field_obj.get("maximum")); try validateConstraintOrder(declared_type, constraints); return constraints; } /// Context for store-field parsing (handles required_set, array items, references, etc.) const StoreFieldContext = struct { fields: *std.ArrayListUnmanaged(types.Field), required_set: *std.StringHashMap(bool), reserve_external_id: bool, fn preValidate(ctx: *@This(), name: []const u8, _: []const u8, def: std.json.Value) !void { if (system.isSystemColumn(name)) return error.ReservedFieldName; if (ctx.reserve_external_id and std.mem.eql(u8, name, "external_id")) return error.ReservedFieldName; try json_read.rejectUnknownKeys(error.UnknownSchemaKey, &store_field_keys, def.object); } fn preObjectValidate(ctx: *@This(), full_name: []const u8) !void { if (ctx.required_set.contains(full_name)) return error.InvalidRequiredField; } fn fieldType(type_str: []const u8) !types.FieldType { return field_type_map.get(type_str) orelse error.UnknownFieldType; } fn emitField(ctx: *@This(), allocator: Allocator, full_name: []const u8, declared_type: types.FieldType, field_def: std.json.Value) !void { if (ctx.fields.items.len >= max_store_fields) return error.TooManyFields; var storage_type = declared_type; var required = false; if (ctx.required_set.getPtr(full_name)) |seen| { seen.* = true; required = true; } const items_type = try extractArrayItemsType(declared_type, field_def); const indexed = (json_read.getBool(field_def.object, "indexed") catch return error.InvalidFieldDefinition) orelse false; if (declared_type == .bytes and indexed) return error.InvalidFieldDefinition; const references = try extractReferences(allocator, field_def.object); errdefer if (references) |ref| allocator.free(ref); if (references != null) { if (declared_type != .text) return error.InvalidFieldType; storage_type = .doc_id; } const on_delete = try extractOnDelete(field_def.object, references != null, required); const metadata = if (field_def.object.get("metadata")) |value| try cloneMetadata(allocator, value) else null; errdefer if (metadata) |md| md.deinit(allocator); const constraints = try parseConstraints(allocator, declared_type, field_def.object); errdefer if (constraints) |c| c.deinit(allocator); const name_quoted = try quoteIdentifier(allocator, full_name); errdefer allocator.free(name_quoted); try ctx.fields.append(allocator, .{ .name = full_name, .name_quoted = name_quoted, .declared_type = declared_type, .storage_type = storage_type, .items_type = items_type, .required = required, .indexed = indexed, .references = references, .on_delete = on_delete, .kind = .user, .metadata = metadata, .constraints = constraints, }); } }; /// Context for presence-field parsing (no nesting limit, max 500 flat fields) const PresenceFieldContext = struct { fields_list: *std.ArrayListUnmanaged(types.PresenceField), fn preValidate(_: *@This(), _: []const u8, type_str: []const u8, def: std.json.Value) !void { if (std.mem.eql(u8, type_str, "object")) { try json_read.rejectUnknownKeys(error.UnknownSchemaKey, &.{ "type", "fields" }, def.object); } else { try json_read.rejectUnknownKeys(error.UnknownSchemaKey, &presence_leaf_field_keys, def.object); } } fn preObjectValidate(_: *@This(), _: []const u8) !void {} fn fieldType(type_str: []const u8) !types.FieldType { return array_item_type_map.get(type_str) orelse error.UnknownFieldType; } fn emitField(ctx: *@This(), allocator: Allocator, full_name: []const u8, declared_type: types.FieldType, field_def: std.json.Value) !void { if (ctx.fields_list.items.len >= max_presence_fields) return error.InvalidSchema; const constraints = try parseConstraints(allocator, declared_type, field_def.object); errdefer if (constraints) |c| c.deinit(allocator); try ctx.fields_list.append(allocator, .{ .name = full_name, .declared_type = declared_type, .constraints = constraints, }); } }; pub fn initFromTables( allocator: Allocator, version: []const u8, root_metadata: ?types.Metadata, declared_tables: []const types.Table, actions: []const types.Action, presence_user_fields: []const types.PresenceField, presence_shared_fields: []const types.PresenceField, presence_user_fields_names: []const []const u8, presence_shared_fields_names: []const []const u8, ) !types.Schema { _ = try Version.parse(version); const version_owned = try allocator.dupe(u8, version); var version_owned_by_schema = false; errdefer if (!version_owned_by_schema) allocator.free(version_owned); var metadata_owned: ?types.Metadata = null; if (root_metadata) |metadata| { metadata_owned = try metadata.clone(allocator); } var metadata_owned_by_schema = false; errdefer if (!metadata_owned_by_schema) if (metadata_owned) |metadata| metadata.deinit(allocator); const owned_tables = try buildTablesSlice(allocator, declared_tables); var tables_owned_by_schema = false; errdefer if (!tables_owned_by_schema) { for (owned_tables.tables[0..owned_tables.built_count]) |*table| table.deinit(allocator); allocator.free(owned_tables.tables); }; var presence_state = try clonePresenceState( allocator, presence_user_fields, presence_shared_fields, presence_user_fields_names, presence_shared_fields_names, ); var presence_owned_by_schema = false; errdefer if (!presence_owned_by_schema) presence_state.deinit(allocator); const cloned_actions = try cloneActions(allocator, actions); var actions_owned_by_schema = false; errdefer if (!actions_owned_by_schema) deinitClonedActions(allocator, cloned_actions); var schema = types.Schema{ .allocator = allocator, .version = version_owned, .tables = owned_tables.tables, .metadata = metadata_owned, .presence_user_fields = presence_state.user_fields, .presence_shared_fields = presence_state.shared_fields, .presence_user_fields_names = presence_state.user_fields_names, .presence_shared_fields_names = presence_state.shared_fields_names, .actions = cloned_actions, }; version_owned_by_schema = true; metadata_owned_by_schema = true; tables_owned_by_schema = true; presence_owned_by_schema = true; actions_owned_by_schema = true; errdefer schema.deinit(); try index.buildTableIndex(allocator, &schema); try index.buildActionIndex(allocator, &schema); try validateReferences(&schema); return schema; } fn clonePresenceFields(allocator: Allocator, fields: []const types.PresenceField) ![]const types.PresenceField { const cloned = try allocator.alloc(types.PresenceField, fields.len); var built: usize = 0; errdefer { for (cloned[0..built]) |f| f.deinit(allocator); allocator.free(cloned); } for (fields) |field| { cloned[built] = try field.clone(allocator); built += 1; } return cloned; } fn cloneActions(allocator: Allocator, actions: []const types.Action) ![]types.Action { const cloned = try allocator.alloc(types.Action, actions.len); var built: usize = 0; errdefer { for (cloned[0..built]) |*action| action.deinit(allocator); allocator.free(cloned); } for (actions) |action| { cloned[built] = try action.clone(allocator); built += 1; } return cloned; } fn deinitClonedActions(allocator: Allocator, actions: []types.Action) void { for (actions) |*action| action.deinit(allocator); allocator.free(actions); } const OwnedTables = struct { tables: []types.Table, built_count: usize, }; fn buildTablesSlice(allocator: Allocator, declared_tables: []const types.Table) !OwnedTables { const has_users = blk: { for (declared_tables) |table| { if (std.mem.eql(u8, table.name, "users")) break :blk true; } break :blk false; }; const table_count = declared_tables.len + @intFromBool(!has_users); var tables = try allocator.alloc(types.Table, table_count); var built_count: usize = 0; errdefer { for (tables[0..built_count]) |*table| table.deinit(allocator); allocator.free(tables); } if (has_users) { for (declared_tables) |table| { if (std.mem.eql(u8, table.name, "users")) { tables[built_count] = try buildRuntimeTable(allocator, table, built_count); built_count += 1; break; } } } else { const users = try implicitUsersTable(allocator); defer { var owned = users; owned.deinit(allocator); } tables[built_count] = try buildRuntimeTable(allocator, users, built_count); built_count += 1; } for (declared_tables) |table| { if (std.mem.eql(u8, table.name, "users")) continue; tables[built_count] = try buildRuntimeTable(allocator, table, built_count); built_count += 1; } return .{ .tables = tables, .built_count = built_count }; } const PresenceState = struct { user_fields: []const types.PresenceField, shared_fields: []const types.PresenceField, user_fields_names: []const []const u8, shared_fields_names: []const []const u8, fn deinit(self: *PresenceState, allocator: Allocator) void { for (self.user_fields) |f| f.deinit(allocator); allocator.free(self.user_fields); for (self.shared_fields) |f| f.deinit(allocator); allocator.free(self.shared_fields); for (self.user_fields_names) |name| allocator.free(name); allocator.free(self.user_fields_names); for (self.shared_fields_names) |name| allocator.free(name); allocator.free(self.shared_fields_names); } }; fn clonePresenceState( allocator: Allocator, presence_user_fields: []const types.PresenceField, presence_shared_fields: []const types.PresenceField, presence_user_fields_names: []const []const u8, presence_shared_fields_names: []const []const u8, ) !PresenceState { const user_fields = try clonePresenceFields(allocator, presence_user_fields); errdefer { for (user_fields) |f| f.deinit(allocator); allocator.free(user_fields); } const shared_fields = try clonePresenceFields(allocator, presence_shared_fields); errdefer { for (shared_fields) |f| f.deinit(allocator); allocator.free(shared_fields); } const user_fields_names = try types.cloneStringSlice(allocator, presence_user_fields_names); errdefer { for (user_fields_names) |name| allocator.free(name); allocator.free(user_fields_names); } const shared_fields_names = try types.cloneStringSlice(allocator, presence_shared_fields_names); errdefer { for (shared_fields_names) |name| allocator.free(name); allocator.free(shared_fields_names); } return .{ .user_fields = user_fields, .shared_fields = shared_fields, .user_fields_names = user_fields_names, .shared_fields_names = shared_fields_names, }; } fn implicitUsersTable(allocator: Allocator) !types.Table { const name = try allocator.dupe(u8, "users"); errdefer allocator.free(name); const name_quoted = try quoteIdentifier(allocator, "users"); errdefer allocator.free(name_quoted); const fields = try allocator.alloc(types.Field, 0); return .{ .name = name, .name_quoted = name_quoted, .fields = fields, .namespaced = false, .is_users_table = true, }; } fn parseTable(allocator: Allocator, table_name_raw: []const u8, table_def: std.json.Value, is_users_table: bool) !types.Table { if (!isValidTableIdentifier(table_name_raw)) return error.InvalidTableName; if (table_def != .object) return error.InvalidTableDefinition; try json_read.rejectUnknownKeys(error.UnknownSchemaKey, &.{ "fields", "required", "namespaced", "metadata", "unique" }, table_def.object); var header = try parseTableHeader(allocator, table_name_raw, table_def.object, is_users_table); errdefer header.deinit(allocator); var required_set = try parseRequiredSet(allocator, table_def.object, is_users_table); defer deinitRequiredSet(allocator, &required_set); const fields = try parseDeclaredFields(allocator, table_def.object, is_users_table, &required_set); errdefer deinitDeclaredFields(allocator, fields); const unique_constraints = try parseUniqueConstraints(allocator, table_def.object, fields); errdefer if (unique_constraints.len > 0) { for (unique_constraints) |c| c.deinit(allocator); allocator.free(unique_constraints); }; return .{ .name = header.name, .name_quoted = header.name_quoted, .fields = fields, .namespaced = header.namespaced, .is_users_table = is_users_table, .metadata = header.metadata, .unique_constraints = unique_constraints, }; } const ParsedTableHeader = struct { name: []const u8, name_quoted: []const u8, namespaced: bool, metadata: ?types.Metadata, fn deinit(self: ParsedTableHeader, allocator: Allocator) void { allocator.free(self.name); allocator.free(self.name_quoted); if (self.metadata) |metadata| metadata.deinit(allocator); } }; fn parseTableHeader( allocator: Allocator, table_name: []const u8, table_obj: std.json.ObjectMap, is_users_table: bool, ) !ParsedTableHeader { const name = try allocator.dupe(u8, table_name); errdefer allocator.free(name); const name_quoted = try quoteIdentifier(allocator, table_name); errdefer allocator.free(name_quoted); const metadata = if (table_obj.get("metadata")) |value| try cloneMetadata(allocator, value) else null; errdefer if (metadata) |value| value.deinit(allocator); const namespaced = (json_read.getBool(table_obj, "namespaced") catch return error.InvalidTableDefinition) orelse !is_users_table; return .{ .name = name, .name_quoted = name_quoted, .namespaced = namespaced, .metadata = metadata, }; } fn parseDeclaredFields( allocator: Allocator, table_obj: std.json.ObjectMap, is_users_table: bool, required_set: *std.StringHashMap(bool), ) ![]types.Field { var fields = std.ArrayListUnmanaged(types.Field).empty; errdefer { for (fields.items) |field| field.deinit(allocator); fields.deinit(allocator); } const fields_value = (json_read.getObject(table_obj, "fields") catch return error.InvalidSchema) orelse return error.MissingFields; try parseFields(allocator, fields_value, &fields, required_set, "", is_users_table); try ensureRequiredFieldsResolved(required_set); return try fields.toOwnedSlice(allocator); } fn deinitDeclaredFields(allocator: Allocator, fields: []const types.Field) void { for (fields) |field| field.deinit(allocator); allocator.free(fields); } fn parseRequiredSet(allocator: Allocator, table_obj: std.json.ObjectMap, is_users_table: bool) !std.StringHashMap(bool) { var required_set = std.StringHashMap(bool).init(allocator); errdefer deinitRequiredSet(allocator, &required_set); const required = (json_read.getArray(table_obj, "required") catch return error.InvalidTableDefinition) orelse return required_set; if (is_users_table) return error.InvalidTableDefinition; for (required.items) |item| { if (item != .string) return error.InvalidTableDefinition; const normalized = try field_path.normalizeDots(allocator, item.string); errdefer allocator.free(normalized); const gop = try required_set.getOrPut(normalized); if (gop.found_existing) { allocator.free(normalized); } else { gop.value_ptr.* = false; } } return required_set; } fn deinitRequiredSet(allocator: Allocator, required_set: *std.StringHashMap(bool)) void { var key_it = required_set.keyIterator(); while (key_it.next()) |key| allocator.free(key.*); required_set.deinit(); } fn ensureRequiredFieldsResolved(required_set: *std.StringHashMap(bool)) !void { var it = required_set.iterator(); while (it.next()) |entry| { if (!entry.value_ptr.*) return error.InvalidRequiredField; } } /// Parse the table-level `unique` array into owned constraints whose field /// indexes are relative to `fields` (the declared user-field list, in order). fn findDeclaredFieldIndex(fields: []const types.Field, name: []const u8) ?usize { for (fields, 0..) |field, index_value| { if (std.mem.eql(u8, field.name, name)) return index_value; } return null; } fn sameFieldSet(left: []const usize, right: []const usize) bool { // O(n²) set comparison; schema counts are startup-bounded // sort copies or add hash sets only if startup profiling proves it matters. if (left.len != right.len) return false; for (left) |field_index| { if (std.mem.indexOfScalar(usize, right, field_index) == null) return false; } return true; } fn parseUniqueConstraint( allocator: Allocator, constraint_value: std.json.Value, declared_fields: []const types.Field, ) !types.UniqueConstraint { if (constraint_value != .array or constraint_value.array.items.len == 0) return error.InvalidUniqueConstraint; const indexes = try allocator.alloc(usize, constraint_value.array.items.len); errdefer allocator.free(indexes); for (constraint_value.array.items, 0..) |component, component_index| { if (component != .string) return error.InvalidUniqueConstraint; const normalized = try field_path.normalizeDots(allocator, component.string); defer allocator.free(normalized); const field_index = findDeclaredFieldIndex(declared_fields, normalized) orelse return error.InvalidUniqueConstraint; if (declared_fields[field_index].declared_type == .bytes) return error.InvalidUniqueConstraint; if (std.mem.indexOfScalar(usize, indexes[0..component_index], field_index) != null) return error.InvalidUniqueConstraint; indexes[component_index] = field_index; } return .{ .field_indexes = indexes }; } fn parseUniqueConstraints( allocator: Allocator, table_obj: std.json.ObjectMap, declared_fields: []const types.Field, ) ![]const types.UniqueConstraint { const unique_value = (json_read.getArray(table_obj, "unique") catch return error.InvalidUniqueConstraint) orelse return &.{}; if (unique_value.items.len == 0) return &.{}; const constraints = try allocator.alloc(types.UniqueConstraint, unique_value.items.len); var built: usize = 0; errdefer { for (constraints[0..built]) |c| c.deinit(allocator); allocator.free(constraints); } for (unique_value.items) |constraint_value| { const constraint = try parseUniqueConstraint(allocator, constraint_value, declared_fields); errdefer constraint.deinit(allocator); // Reject duplicate constraint field sets regardless of order. for (constraints[0..built]) |existing| { if (sameFieldSet(existing.field_indexes, constraint.field_indexes)) return error.InvalidUniqueConstraint; } constraints[built] = constraint; built += 1; } return constraints[0..built]; } fn parseFields( allocator: Allocator, fields_value: std.json.ObjectMap, fields: *std.ArrayListUnmanaged(types.Field), required_set: *std.StringHashMap(bool), prefix: []const u8, reserve_external_id: bool, ) !void { var ctx = StoreFieldContext{ .fields = fields, .required_set = required_set, .reserve_external_id = reserve_external_id, }; try parseObjectFields(allocator, fields_value, prefix, StoreFieldContext, &ctx); } pub fn buildRuntimeTable(allocator: Allocator, declared: types.Table, table_index: usize) !types.Table { var table = try initRuntimeTable(allocator, declared, table_index); errdefer table.deinit(allocator); try index.buildFieldIndex(allocator, &table); try buildRuntimeTableSql(allocator, &table); return table; } fn initRuntimeTable(allocator: Allocator, declared: types.Table, table_index: usize) !types.Table { const name = try allocator.dupe(u8, declared.name); errdefer allocator.free(name); const name_quoted = if (declared.name_quoted.len > 0) try allocator.dupe(u8, declared.name_quoted) else try quoteIdentifier(allocator, declared.name); errdefer allocator.free(name_quoted); const metadata = if (declared.metadata) |md| try md.clone(allocator) else null; errdefer if (metadata) |md| md.deinit(allocator); // Constraints stay relative to `userFields()`; no system-field offset is applied. const unique_constraints = try cloneUniqueConstraints(allocator, declared.unique_constraints); errdefer if (unique_constraints.len > 0) { for (unique_constraints) |constraint| constraint.deinit(allocator); allocator.free(unique_constraints); }; const fields = try buildRuntimeFields(allocator, declared.fields); const user_field_start = system.leading_system_field_count; return .{ .name = name, .name_quoted = name_quoted, .fields = fields, .namespaced = declared.namespaced, .is_users_table = std.mem.eql(u8, declared.name, "users") or declared.is_users_table, .index = table_index, .canonical_fields = true, .user_field_start = user_field_start, .user_field_end = user_field_start + declared.fields.len, .metadata = metadata, .unique_constraints = unique_constraints, }; } fn buildRuntimeTableSql(allocator: Allocator, table: *types.Table) !void { table.select_from_sql = try sql_strings.buildSelectFromSql(allocator, table); table.select_document_sql = try sql_strings.buildSelectDocumentSql(allocator, table.select_from_sql); table.delete_document_sql_prefix = try sql_strings.buildDeleteDocumentSqlPrefix(allocator, table); table.delete_document_sql_suffix = try sql_strings.buildDeleteDocumentSqlSuffix(allocator, table); } fn cloneUniqueConstraints(allocator: Allocator, constraints: []const types.UniqueConstraint) ![]const types.UniqueConstraint { if (constraints.len == 0) return &.{}; const cloned = try allocator.alloc(types.UniqueConstraint, constraints.len); var initialized: usize = 0; errdefer { for (cloned[0..initialized]) |constraint| constraint.deinit(allocator); allocator.free(cloned); } for (constraints) |constraint| { cloned[initialized] = try constraint.clone(allocator); initialized += 1; } return cloned; } fn buildRuntimeFields(allocator: Allocator, declared_fields: []const types.Field) ![]types.Field { const total_fields = system.leading_system_field_count + declared_fields.len + system.trailing_system_field_count; const fields = try allocator.alloc(types.Field, total_fields); var initialized: usize = 0; errdefer { for (fields[0..initialized]) |field| field.deinit(allocator); allocator.free(fields); } for (system.leading_system_fields) |field| { fields[initialized] = field; initialized += 1; } for (declared_fields) |field| { fields[initialized] = try cloneUserField(allocator, field); fields[initialized].kind = .user; initialized += 1; } for (system.trailing_system_fields) |field| { fields[initialized] = field; initialized += 1; } return fields; } fn cloneUserField(allocator: Allocator, field: types.Field) !types.Field { var cloned = try field.clone(allocator); errdefer cloned.deinit(allocator); if (cloned.name_quoted.len == 0) { allocator.free(cloned.name_quoted); cloned.name_quoted = try quoteIdentifier(allocator, cloned.name); } return cloned; } fn validateReferences(schema: *const types.Schema) !void { for (schema.tables) |table| { for (table.userFields()) |field| { if (field.references) |target| { if (schema.table(target) == null) return error.InvalidReference; } } } } const primitive_type_kvs = .{ .{ "string", types.FieldType.text }, .{ "integer", types.FieldType.integer }, .{ "number", types.FieldType.real }, .{ "boolean", types.FieldType.boolean }, }; const field_type_map = std.StaticStringMap(types.FieldType).initComptime(primitive_type_kvs ++ .{ .{ "array", types.FieldType.array }, .{ "bytes", types.FieldType.bytes }, }); const array_item_type_map = std.StaticStringMap(types.FieldType).initComptime(primitive_type_kvs); fn quoteIdentifier(allocator: Allocator, name: []const u8) ![]const u8 { return std.mem.concat(allocator, u8, &.{ "\"", name, "\"" }); } fn extractArrayItemsType(declared_type: types.FieldType, field_def: std.json.Value) !?types.FieldType { if (declared_type != .array) return null; const items_val = (json_read.getString(field_def.object, "items") catch return error.InvalidArrayItems) orelse return error.MissingArrayItems; return array_item_type_map.get(items_val) orelse error.UnsupportedArrayItemsType; } fn extractReferences(allocator: Allocator, field_def: std.json.ObjectMap) !?[]const u8 { const val = (json_read.getString(field_def, "references") catch return error.InvalidReference) orelse return null; if (!isValidTableIdentifier(val)) return error.InvalidTableName; return try allocator.dupe(u8, val); } fn extractOnDelete(field_def: std.json.ObjectMap, has_references: bool, required: bool) !?types.OnDelete { const val = (json_read.getString(field_def, "onDelete") catch return error.InvalidOnDelete) orelse return if (has_references) .restrict else null; const parsed = std.meta.stringToEnum(types.OnDelete, val) orelse return error.InvalidOnDelete; if (parsed == .set_null and required) return error.InvalidOnDelete; return parsed; } fn isValidTableIdentifier(name: []const u8) bool { if (!isValidSchemaIdentifier(name)) return false; if (system.isInternalTableName(name)) return false; return true; } fn isValidFieldIdentifier(name: []const u8) bool { return isValidSchemaIdentifier(name); } fn isValidSchemaIdentifier(name: []const u8) bool { if (name.len == 0) return false; if (!std.ascii.isAlphabetic(name[0])) return false; if (std.mem.containsAtLeast(u8, name, 1, "__")) return false; for (name[1..]) |char| { if (!std.ascii.isAlphanumeric(char) and char != '_') return false; } return true; }