@visiolab/effect-firebase 0.0.0-stage → 0.3.1

package/dist/firestore/internal/firestoreModel.mjs

@@ -0,0 +1,719 @@
+import { isDeleteField } from "./fieldValue.mjs";
+import { equals } from "./firestoreValueWalk.mjs";
+import { toCodecFirestore } from "./firestoreValue.mjs";
+import { ArrayOr, DeleteField, DeleteFieldOr, IncrementOr, ServerTimestampOr } from "./firestoreSchema.mjs";
+import { isReplace, replace } from "./patch.mjs";
+import { Effect, Predicate, Result, Schema, SchemaAST, SchemaGetter, SchemaIssue, SchemaParser } from "effect";
+import { VariantSchema } from "effect/schema";
+// src/firestore/internal/firestoreModel.ts
+const Variants = VariantSchema.make({
+	variants: [
+		"read",
+		"create",
+		"update"
+	],
+	defaultVariant: "read"
+});
+/** @internal */
+const Field = Variants.Field;
+/** @internal */
+const FieldOnly = Variants.FieldOnly;
+/** @internal */
+const FieldExcept = Variants.FieldExcept;
+/** @internal */
+const Struct$1 = Variants.Struct;
+/** @internal */
+const fieldEvolve = Variants.fieldEvolve;
+/** @internal */
+const extract = Variants.extract;
+/** @internal */
+const UnionTypeId = "~@visiolab/effect-firebase/firestore/FirestoreModel/Union";
+const FieldTypeId = "~effect/schema/VariantSchema/Field";
+/** @internal */
+const fields = (self) => VariantSchema.fields(self);
+/** @internal */
+const RecordTypeId = "~@visiolab/effect-firebase/firestore/FirestoreModel/Record";
+/** No path yet, to gather an update's into. */
+const emptyPaths = () => ({
+	known: {},
+	patterns: /* @__PURE__ */ new Map()
+});
+/**
+* Throws on a field name holding a dot, which a path would read as two.
+*/
+const assertFieldName = (key) => {
+	if (key.includes(".")) throw new Error(`Invalid Firestore field name "${key}": it must not contain "."`);
+};
+/** The reason a key is not one a path can name on its own, if it is not. */
+const unaddressable = (key) => key === "" ? "must not be empty" : key.includes(".") ? "must not contain \".\"" : void 0;
+/** A key a path names on its own, which is a non-empty one holding no dot. */
+const Segment = Schema.String.check(Schema.isPattern(/^[^.]+$/));
+/** Where a path sits, with `*` for each key only the data names. */
+const where = (path) => path.map((segment) => Schema.isSchema(segment) ? "*" : segment).join(".");
+/**
+* The parts of the template literal a path matches: the names of the fields
+* along it, joined by dots, and `key` for each key of a Record.
+*/
+const template = (path, key) => {
+	const parts = [];
+	let literal = "";
+	path.forEach((segment, i) => {
+		if (i > 0) literal += ".";
+		if (Schema.isSchema(segment)) {
+			if (literal !== "") parts.push(literal);
+			parts.push(key(segment, i));
+			literal = "";
+		} else literal += segment;
+	});
+	if (literal !== "") parts.push(literal);
+	return parts;
+};
+/**
+* The key of a pattern of paths, as an update is written with it and as
+* Firestore holds it: each key of a Record is encoded by the Record's key
+* schema, and refused where its encoded form is one no path can name.
+*/
+const PathKey = (path) => {
+	const encoded = template(path, (key, i) => Schema.String.check(Schema.makeFilter((segment) => {
+		const reason = unaddressable(segment);
+		return reason === void 0 ? void 0 : `Invalid Firestore field name "${segment}" in "${where(path.slice(0, i))}": it ${reason}`;
+	})).pipe(Schema.decodeTo(key)));
+	const decoded = template(path, (key) => recordKeys(key).rest ? Segment : Schema.toType(key));
+	return Schema.TemplateLiteralParser(encoded).pipe(Schema.decodeTo(Schema.TemplateLiteral(decoded), {
+		decode: SchemaGetter.transform((parts) => parts.join("")),
+		encode: SchemaGetter.transform((key) => {
+			const segments = key.split(".");
+			return template(path, (_, i) => segments[i]);
+		})
+	}));
+};
+const addPath = (paths, path, schema) => {
+	if (path.every((segment) => typeof segment === "string")) paths.known[path.join(".")] = Schema.optionalKey(schema);
+	else if (!paths.patterns.has(where(path))) paths.patterns.set(where(path), Schema.Record(PathKey(path), withoutOptionalKey(schema)));
+};
+const variantSchema = (field, variant) => VariantSchema.isStruct(field) ? extract(field, variant) : VariantSchema.isField(field) ? field.schemas[variant] : field;
+const updateSchema = (field) => VariantSchema.isStruct(field) ? void 0 : variantSchema(field, "update");
+const replaceContext = SchemaAST.replaceContext;
+/**
+* Drops the default a field is constructed with. A patch leaves a key out to
+* keep what the document holds, so filling one in would overwrite it.
+*/
+const withoutConstructorDefault = (schema) => {
+	const context = schema.ast.context;
+	if (context?.constructorDefault === void 0) return schema;
+	return Schema.make(replaceContext(schema.ast, new SchemaAST.Context(context.isOptional, context.isMutable, void 0, context.annotations)));
+};
+/**
+* Drops the optional key a schema is made, for a value at a key only the data
+* names, which may be missing whatever it holds.
+*/
+const withoutOptionalKey = (schema) => {
+	const context = schema.ast.context;
+	if (context?.isOptional !== true) return schema;
+	return Schema.make(replaceContext(schema.ast, new SchemaAST.Context(false, context.isMutable, context.constructorDefault, context.annotations)));
+};
+/** The keys a Record key schema names up front, and whether the data names more. */
+const recordKeys = (key) => {
+	const ast = Schema.Record(key, Schema.Unknown).ast;
+	const known = ast.propertySignatures.map(({ name }) => {
+		if (typeof name === "symbol") throw new Error(`Invalid Firestore field name ${String(name)}: it must be a string`);
+		const segment = String(name);
+		const reason = unaddressable(segment);
+		if (reason !== void 0) throw new Error(`Invalid Firestore field name "${segment}": it ${reason}`);
+		return segment;
+	});
+	const rest = ast.indexSignatures.length > 0;
+	if (rest && known.length > 0) throw new Error(`Invalid Record key: it names ${known.map((k) => `"${k}"`).join(", ")} besides keys only the data names, which an update cannot tell apart`);
+	return {
+		known,
+		rest
+	};
+};
+const recordNode = (key, value, create, optional) => {
+	const keys = recordKeys(key);
+	return {
+		fields: Object.fromEntries(keys.known.map((k) => [k, value])),
+		key: keys.rest ? void 0 : key,
+		rest: keys.rest ? {
+			key,
+			value
+		} : void 0,
+		create,
+		optional,
+		writable: nodeOf(value)?.writable ?? updateSchema(value) !== void 0
+	};
+};
+/** Whether a field was made {@link FirestoreModel.Optional}. */
+const isOptional = (field) => Predicate.hasProperty(field, "~optionality") && field["~optionality"] === "optional";
+/** What a field reaches into, if it is a struct or a Record. */
+const nodeOf = (field, optional = false) => {
+	if (isOptional(field)) return nodeOf(field.field, true);
+	if (Predicate.hasProperty(field, "~@visiolab/effect-firebase/firestore/FirestoreModel/Union")) return unionNode(field[UnionTypeId], optional);
+	if (Predicate.hasProperty(field, "~@visiolab/effect-firebase/firestore/FirestoreModel/Record")) {
+		const { key, value } = field[RecordTypeId];
+		return recordNode(key, value, () => variantSchema(field, "create"), optional);
+	}
+	if (VariantSchema.isStruct(field)) return {
+		fields: VariantSchema.fields(field),
+		key: void 0,
+		rest: void 0,
+		create: () => extract(field, "create"),
+		optional,
+		writable: true
+	};
+};
+/**
+* Whether a set of fields may be written whole by an update: only where every
+* field it holds, at any depth, is written both by `set`, whose shape a
+* replacement takes, and by an update. Replacing one holding a field written
+* once would change it, and one holding a field `set` leaves out would drop it.
+*/
+const isReplaceable = (fields) => Object.values(fields).every((field) => {
+	const node = nodeOf(field);
+	return node === void 0 ? variantSchema(field, "create") !== void 0 && updateSchema(field) !== void 0 : isNodeReplaceable(node);
+});
+const isNodeReplaceable = (node) => node.members !== void 0 ? node.members.every(isMemberReplaceable) : isReplaceable(node.fields) && (node.rest === void 0 || isReplaceable({ _: node.rest.value }));
+const isMemberReplaceable = (member) => isReplaceable(fields(member));
+/** The union of what `set` writes each of `members` as. */
+const unionCreate = (members) => Schema.Union(members.map((member) => extract(member, "create")));
+const unionNode = (members, optional) => ({
+	fields: {},
+	members,
+	key: void 0,
+	rest: void 0,
+	create: () => unionCreate(members),
+	optional,
+	writable: optional || members.some(isMemberReplaceable) || hasSharedField(members.map(fields))
+});
+/**
+* The replacement of a struct, holding the struct as `create` makes it - with
+* its constructor defaults filled in, since a default left out of a struct
+* written whole would be a field dropped.
+*
+* Given several, as the unions the members of a union hold at one key are, it
+* is made by every one of them, each of which must take it, and holds it as
+* the first makes it. That they also store it the same way is for the schema
+* of its path to tell - see {@link SharedValueSchema}.
+*/
+const ReplaceSchema = (creates) => Schema.declareConstructor()(creates, (creates) => (input, ast, options) => {
+	if (!isReplace(input)) return Effect.fail(new SchemaIssue.InvalidType(ast, input, options));
+	return Effect.forEach(creates, (create) => create.makeEffect(input.value, options)).pipe(Effect.mapBothEager({
+		onSuccess: ([made]) => replace(made),
+		onFailure: (issue) => new SchemaIssue.Pointer(["value"], issue)
+	}));
+}, { expected: "a struct written whole" });
+/**
+* The patch of a struct, refusing the markers a `Schema.Struct` would
+* otherwise take for a patch of nothing, since it keeps only the keys it knows.
+*/
+const StructPatchSchema = (fields) => Schema.declareConstructor()([fields], ([fields]) => (input, ast, options) => isReplace(input) || isDeleteField(input) ? Effect.fail(new SchemaIssue.InvalidType(ast, input, options)) : SchemaParser.decodeUnknownEffect(fields)(input, options), { expected: "a patch of a struct" });
+/**
+* Builds the patch a set of fields is updated through in `mode`, along with
+* where its structs and Records sit, and gathers the schema of each path it can
+* write at into `paths`.
+*
+* A struct takes a patch, written at its paths, unless it may be missing and
+* the patch is checked, since the patch would create it holding only what it
+* carried. It takes a replacement wherever it is replaceable, and a removal
+* where it may be missing. A Record is a struct whose keys may come from the
+* data - see {@link buildNode}.
+*
+* Where `recordKey` is given, the fields are the keys of a Record keyed by
+* literals, and each sits on its path as that key schema encodes it.
+*
+* Throws on a field name holding a dot, which a path would read as two.
+*/
+const build = (fields, path, paths, mode, recordKey) => {
+	const schemas = {};
+	const shapes = {};
+	for (const key of Object.keys(fields)) {
+		assertFieldName(key);
+		const field = fields[key];
+		const at = [...path, recordKey ?? key];
+		const node = nodeOf(field);
+		if (node !== void 0) {
+			if (node.writable) {
+				const built = buildNode(node, at, paths, mode);
+				schemas[key] = Schema.optionalKey(built.schema);
+				shapes[key] = built.shape;
+			}
+		} else {
+			const update = updateSchema(field);
+			if (update !== void 0) {
+				const schema = withoutConstructorDefault(update);
+				schemas[key] = Schema.optionalKey(schema);
+				addPath(paths, at, schema);
+			}
+		}
+	}
+	return {
+		patch: Schema.Struct(schemas),
+		shape: {
+			fields: shapes,
+			rest: void 0
+		}
+	};
+};
+/**
+* Builds what a struct or a Record at `path` takes in `mode`, gathering the
+* paths it writes at into `paths`, the way {@link build} does for a set of
+* fields.
+*
+* A Record whose keys come from the data is patched key by key, each key
+* written at its own path. Any such key may be missing, so each takes the
+* removal, and a value that is itself a struct or a Record is treated as one a
+* document may go without. That also makes a patch safe where the Record
+* itself may be missing: every key it writes is one the Record may hold or not.
+*/
+const buildNode = (node, path, paths, mode) => {
+	if (node.members !== void 0) return buildUnion(node, node.members, path, paths, mode);
+	const inner = node.rest === void 0 ? build(node.fields, path, paths, mode, node.key) : buildRest(node.rest, path, paths, mode);
+	const create = isNodeReplaceable(node) ? node.create() : void 0;
+	const takes = [];
+	if (!node.optional || mode === "unchecked" || node.rest !== void 0) takes.push(StructPatchSchema(inner.patch));
+	if (create !== void 0) takes.push(ReplaceSchema([create]));
+	if (node.optional) takes.push(DeleteField);
+	const written = node.optional ? create === void 0 ? DeleteField : DeleteFieldOr(create) : create;
+	if (written !== void 0) addPath(paths, path, written);
+	return {
+		schema: takes.length === 1 ? takes[0] : Schema.Union(takes),
+		shape: inner.shape
+	};
+};
+/**
+* Builds what a union at `path` takes in `mode`, gathering the paths it writes
+* at into `paths`. A union is replaced with any member it may be replaced
+* with, removed where it may be missing, and patched at its Shared Fields -
+* and, unchecked, at a key only some members hold - see {@link buildShared}.
+* The patch is refused where it may be missing and the patch is checked, as it
+* is for a struct. One that takes none of these in `mode` takes nothing.
+*/
+const buildUnion = (node, members, path, paths, mode) => {
+	const replaceable = members.filter(isMemberReplaceable);
+	const create = replaceable.length === 0 ? void 0 : unionCreate(replaceable);
+	const shared = buildShared(members.map(fields), path, paths, mode);
+	const takes = [];
+	if (shared.keys.length > 0 && (!node.optional || mode === "unchecked")) takes.push(shared.patch);
+	if (create !== void 0) takes.push(ReplaceSchema([create]));
+	if (node.optional) takes.push(DeleteField);
+	const written = node.optional ? create === void 0 ? DeleteField : DeleteFieldOr(create) : create;
+	if (written !== void 0) addPath(paths, path, written);
+	return {
+		schema: takes.length === 1 ? takes[0] : Schema.Union(takes),
+		shape: shared.shape
+	};
+};
+/** What a field was made {@link FirestoreModel.Optional} of, or the field itself. */
+const unwrap = (field) => isOptional(field) ? field.field : field;
+/** The types a type is a union of, or the type itself. */
+const constituents = (ast) => SchemaAST.isUnion(ast) ? ast.types.flatMap(constituents) : [ast];
+/** What a declaration is told apart by, where it says. */
+const declarationId = (ast) => (ast.annotations?.representation)?.id;
+/** The type of a literal a keyword is the type of. */
+const keywordOf = (literal) => typeof literal === "string" ? "String" : typeof literal === "number" ? "Number" : typeof literal === "boolean" ? "Boolean" : "BigInt";
+/**
+* Whether every value of `a` is one of `b`, the way TypeScript tells whether
+* one type extends another, as far as the schemas say. Where they do not say -
+* a declaration with nothing to tell it apart by, a suspended schema - it is
+* taken to be, so the encoding decides.
+*/
+const isSubtype = (a, b) => {
+	if (SchemaAST.isUnion(a)) return a.types.every((type) => isSubtype(type, b));
+	if (SchemaAST.isUnion(b)) return b.types.some((type) => isSubtype(a, type));
+	if (SchemaAST.isAny(b) || SchemaAST.isUnknown(b) || SchemaAST.isNever(a) || SchemaAST.isAny(a)) return true;
+	if (SchemaAST.isSuspend(a) || SchemaAST.isSuspend(b)) return true;
+	if (SchemaAST.isLiteral(a)) return SchemaAST.isLiteral(b) ? a.literal === b.literal : SchemaAST.isEnum(b) ? b.enums.some(([, value]) => value === a.literal) : SchemaAST.isTemplateLiteral(b) ? typeof a.literal === "string" : b._tag === keywordOf(a.literal);
+	if (SchemaAST.isEnum(a)) return a.enums.every(([, value]) => isSubtype(new SchemaAST.Literal(value), b));
+	if (SchemaAST.isTemplateLiteral(a)) return SchemaAST.isString(b) || SchemaAST.isTemplateLiteral(b);
+	if (SchemaAST.isUniqueSymbol(a)) return SchemaAST.isSymbol(b) || SchemaAST.isUniqueSymbol(b) && a.symbol === b.symbol;
+	if (SchemaAST.isUndefined(a) && SchemaAST.isVoid(b)) return true;
+	if (SchemaAST.isObjectKeyword(b)) return SchemaAST.isObjectKeyword(a) || SchemaAST.isObjects(a) || SchemaAST.isArrays(a) || SchemaAST.isDeclaration(a);
+	if (SchemaAST.isDeclaration(a)) {
+		if (SchemaAST.isDeclaration(b)) {
+			const [ida, idb] = [declarationId(a), declarationId(b)];
+			return a === b || ida === void 0 || idb === void 0 || ida === idb && a.typeParameters.length === b.typeParameters.length && a.typeParameters.every((p, i) => isSubtype(p, b.typeParameters[i]));
+		}
+		return SchemaAST.isObjects(b);
+	}
+	if (SchemaAST.isObjects(a)) {
+		if (SchemaAST.isDeclaration(b)) return declarationId(b) === void 0;
+		if (!SchemaAST.isObjects(b)) return false;
+		const own = new Map(a.propertySignatures.map((p) => [p.name, p.type]));
+		return b.propertySignatures.every((p) => {
+			const type = own.get(p.name);
+			return type === void 0 ? SchemaAST.isOptional(p.type) : (SchemaAST.isOptional(p.type) || !SchemaAST.isOptional(type)) && isSubtype(type, p.type);
+		}) && b.indexSignatures.every((index) => [...a.propertySignatures, ...a.indexSignatures].every((p) => isSubtype(p.type, index.type)));
+	}
+	if (SchemaAST.isArrays(a)) {
+		if (!SchemaAST.isArrays(b)) return false;
+		if (b.elements.length === 0 && b.rest.length === 1) return [...a.elements, ...a.rest].every((type) => isSubtype(type, b.rest[0]));
+		if (a.rest.length === 0 && b.rest.length === 0) return a.elements.length <= b.elements.length && b.elements.every((type, i) => {
+			const own = a.elements[i];
+			return own === void 0 ? SchemaAST.isOptional(type) : (SchemaAST.isOptional(type) || !SchemaAST.isOptional(own)) && isSubtype(own, type);
+		});
+		return a.elements.length === b.elements.length && a.rest.length === b.rest.length && [...a.elements, ...a.rest].every((type, i) => isSubtype(type, [...b.elements, ...b.rest][i]));
+	}
+	return a._tag === b._tag;
+};
+/**
+* The values out of `a` and `b` that the other takes too: each type `a` is a
+* union of that `b` takes whole, and the other way round, as `Meet` works it
+* out in the types.
+*/
+const meet = (a, b) => {
+	const within = (types) => (type) => types.some((other) => isSubtype(type, other));
+	return [...a.filter(within(b)), ...b.filter(within(a))];
+};
+/**
+* Whether some value is taken by every one of `schemas`, as `MeetAll` tells it
+* in the types, so a key is shared, and has a path, exactly where its type
+* says. The literal that tells members apart takes none.
+*/
+const haveValueInCommon = (schemas) => schemas.map((schema) => constituents(schema.ast)).reduceRight((acc, types) => meet(types, acc)).length > 0;
+/**
+* What a Shared Field is patched through: the value is encoded through the
+* field of every member, each of which must take it, and all of which must
+* store it as the same Firestore Value. Each member decides by the canonical
+* codec, not by the encoding the caller asks for, since that is what Firestore
+* ends up holding. It is written as the first member writes it, which is then
+* what every member would write.
+*/
+const SharedValueSchema = (schemas) => {
+	if (schemas.length === 1) return schemas[0];
+	const codecs = schemas.map((schema) => toCodecFirestore(schema));
+	return schemas[0].check(Schema.makeFilter((value, _, options) => {
+		let stored;
+		for (const [i, codec] of codecs.entries()) {
+			const result = SchemaParser.encodeUnknownResult(codec)(value, options);
+			if (Result.isFailure(result)) return result.failure;
+			if (i === 0) stored = result.success;
+			else if (!equals(stored, result.success)) return "Expected a value every member of the union stores the same way";
+		}
+	}, { expected: "a value every member of the union takes and stores the same way" }));
+};
+/**
+* The patch of the Shared Fields of a union, refusing a key it does not know,
+* since a `Schema.Struct` would otherwise drop it and write nothing. That is a
+* key some member goes without, or one the members cannot agree on, such as
+* the literal they are told apart by.
+*/
+const SharedPatchSchema = (fields, keys) => Schema.declareConstructor()([fields], ([fields]) => (input, ast, options) => {
+	if (isReplace(input) || isDeleteField(input)) return Effect.fail(new SchemaIssue.InvalidType(ast, input, options));
+	if (Predicate.isObject(input)) {
+		const unknown = Object.keys(input).find((key) => !keys.includes(key));
+		if (unknown !== void 0) return Effect.fail(new SchemaIssue.Pointer([unknown], new SchemaIssue.UnexpectedKey(ast, input[unknown])));
+	}
+	return SchemaParser.decodeUnknownEffect(fields)(input, options);
+}, { expected: "a patch of the Shared Fields of a union" });
+/**
+* Builds the patch of the Shared Fields of a union, given the fields of each
+* of its members, along with where the structs among them sit, and gathers the
+* schema of each path it can write at into `paths`.
+*
+* A Shared Field is a key every member holds, at which every member takes an
+* update: a value, patched through {@link SharedValueSchema}, or a struct,
+* patched at its own Shared Fields by the same rule one level down. A struct
+* every member may go without takes the removal alone, and one only some
+* members may go without takes nothing. A union is shared by the rule a union
+* field is written by - see {@link buildSharedUnion}. A Record is not shared.
+* Where no value is taken by every member's type, as
+* {@link haveValueInCommon} tells, the key is not shared either, which is what
+* keeps it out of `paths` exactly where the type keeps it out.
+*
+* Under `unchecked`, a key only some members hold is patched by the same rule
+* over just those members. Its path is gathered in either mode, so the paths
+* are the same in both and only the patch tells them apart.
+*
+* {@link hasSharedField} tells, without building any of it, whether this
+* takes any key under `unchecked`, and must agree with it.
+*/
+const buildShared = (memberFields, path, paths, mode) => {
+	const schemas = {};
+	const shapes = {};
+	for (const key of keysOf(memberFields)) {
+		assertFieldName(key);
+		const holding = memberFields.filter((f) => Object.hasOwn(f, key));
+		const taken = holding.length === memberFields.length || mode === "unchecked";
+		const at = [...path, key];
+		const atKey = holding.map((f) => f[key]);
+		if (atKey.every(isStructField)) {
+			if (atKey.every((field) => !isOptional(field))) {
+				const inner = buildShared(atKey.map(structFields), at, paths, mode);
+				if (taken && inner.keys.length > 0) {
+					schemas[key] = Schema.optionalKey(inner.patch);
+					shapes[key] = inner.shape;
+				}
+			} else if (atKey.every(isOptional)) {
+				if (taken) schemas[key] = Schema.optionalKey(DeleteField);
+				addPath(paths, at, DeleteField);
+			}
+		} else if (atKey.every(isUnionField)) {
+			const built = buildSharedUnion(atKey, at, paths, mode);
+			if (taken && built !== void 0) {
+				schemas[key] = Schema.optionalKey(built.schema);
+				shapes[key] = built.shape;
+			}
+		} else if (atKey.every((field) => !isNodeField(field))) {
+			const updates = atKey.map(updateSchema);
+			if (updates.every((u) => u !== void 0) && haveValueInCommon(updates)) {
+				const schema = SharedValueSchema(updates.map(withoutConstructorDefault));
+				if (taken) schemas[key] = Schema.optionalKey(schema);
+				addPath(paths, at, schema);
+			}
+		}
+	}
+	const keys = Object.keys(schemas);
+	return {
+		patch: SharedPatchSchema(Schema.Struct(schemas), keys),
+		shape: {
+			fields: shapes,
+			rest: void 0
+		},
+		keys
+	};
+};
+/** The keys any of the members holding `memberFields` holds. */
+const keysOf = (memberFields) => [...new Set(memberFields.flatMap((f) => Object.keys(f)))];
+/** Whether a field is a struct, {@link FirestoreModel.Optional} or not. */
+const isStructField = (field) => VariantSchema.isStruct(unwrap(field));
+/** The fields of the struct a field is, {@link FirestoreModel.Optional} or not. */
+const structFields = (field) => fields(unwrap(field));
+/** Whether a field is a union, {@link FirestoreModel.Optional} or not. */
+const isUnionField = (field) => Predicate.hasProperty(unwrap(field), UnionTypeId);
+/** The members of the union a field is, {@link FirestoreModel.Optional} or not. */
+const unionMembers = (field) => unwrap(field)[UnionTypeId];
+/** Whether an update reaches into a field: a struct, a Record or a union. */
+const isNodeField = (field) => isStructField(field) || isUnionField(field) || Predicate.hasProperty(unwrap(field), "~@visiolab/effect-firebase/firestore/FirestoreModel/Record");
+/** The fields of every member of each of the unions `atKey`, in one list. */
+const unionsMemberFields = (atKey) => atKey.flatMap((field) => unionMembers(field).map(fields));
+/**
+* What each of the unions `atKey` is replaced with, where every one of them is
+* replaced with something and some value is taken by all of them, as the type
+* tells it.
+*/
+const sharedReplacement = (atKey) => {
+	const creates = [];
+	for (const field of atKey) {
+		const replaceable = unionMembers(field).filter(isMemberReplaceable);
+		if (replaceable.length === 0) return;
+		creates.push(unionCreate(replaceable));
+	}
+	return haveValueInCommon(creates) ? creates : void 0;
+};
+/**
+* Builds what the unions `atKey` the members of a union hold at one key take
+* in `mode`, gathering the paths it writes at into `paths`, or `undefined`
+* where they take nothing. It is the rule a union field is written by, held to
+* every one of them: a replacement every one takes and stores the same way,
+* the removal where every one may be missing, and a patch at the Shared Fields
+* of all their members together, refused where any of them may be missing and
+* the patch is checked.
+*/
+const buildSharedUnion = (atKey, path, paths, mode) => {
+	const optional = atKey.every(isOptional);
+	const creates = sharedReplacement(atKey);
+	const shared = buildShared(unionsMemberFields(atKey), path, paths, mode);
+	const takes = [];
+	if (shared.keys.length > 0 && (mode === "unchecked" || !atKey.some(isOptional))) takes.push(shared.patch);
+	if (creates !== void 0) takes.push(ReplaceSchema(creates));
+	if (optional) takes.push(DeleteField);
+	const whole = creates === void 0 ? void 0 : SharedValueSchema(creates);
+	const written = optional ? whole === void 0 ? DeleteField : DeleteFieldOr(whole) : whole;
+	if (written !== void 0) addPath(paths, path, written);
+	return takes.length === 0 ? void 0 : {
+		schema: takes.length === 1 ? takes[0] : Schema.Union(takes),
+		shape: shared.shape
+	};
+};
+/**
+* Whether members holding `memberFields` take any key under `unchecked`, as
+* {@link buildShared} would build it, but without building a schema.
+*/
+const hasSharedField = (memberFields) => keysOf(memberFields).some((key) => {
+	const atKey = memberFields.filter((f) => Object.hasOwn(f, key)).map((f) => f[key]);
+	if (atKey.every(isStructField)) return atKey.every((field) => !isOptional(field)) ? hasSharedField(atKey.map(structFields)) : atKey.every(isOptional);
+	if (atKey.every(isUnionField)) return atKey.every(isOptional) || sharedReplacement(atKey) !== void 0 || hasSharedField(unionsMemberFields(atKey));
+	if (atKey.every((field) => !isNodeField(field))) {
+		const updates = atKey.map(updateSchema);
+		return updates.every((u) => u !== void 0) && haveValueInCommon(updates);
+	}
+	return false;
+});
+/** Builds the patch of a Record at the keys only the data names. */
+const buildRest = (rest, path, paths, mode) => {
+	const entryPath = [...path, rest.key];
+	const node = nodeOf(rest.value, true);
+	let entry;
+	let shape;
+	if (node !== void 0) {
+		const built = buildNode({
+			...node,
+			optional: true
+		}, entryPath, paths, mode);
+		entry = built.schema;
+		shape = built.shape;
+	} else {
+		entry = DeleteFieldOr(withoutConstructorDefault(withoutOptionalKey(updateSchema(rest.value))));
+		addPath(paths, entryPath, entry);
+	}
+	return {
+		patch: Schema.Record(Schema.toType(rest.key), entry),
+		shape: {
+			fields: {},
+			rest: { value: shape }
+		}
+	};
+};
+/**
+* Goes one level down where the shape says a struct or a Record sits, unless it
+* is being removed or replaced. It runs on the patch as the caller wrote it,
+* before anything is encoded, so the removal and the replacement are still
+* this library's to recognise.
+*
+* A replacement is written whole, as the struct it holds. A key of a Record
+* fails where no path could name it; the paths it builds are encoded by the
+* schema of each, keys and all.
+*/
+const flatten = (value, shape, prefix, out, options) => Effect.gen(function* () {
+	for (const key of Object.keys(value)) {
+		const inner = value[key];
+		let child;
+		if (shape.rest !== void 0) {
+			const reason = unaddressable(key);
+			if (reason !== void 0) return yield* Effect.fail(new SchemaIssue.InvalidValue({ message: `Invalid Firestore field name "${key}" in "${prefix.slice(0, -1)}": it ${reason}` }, key, options));
+			child = shape.rest.value;
+		} else if (Object.hasOwn(shape.fields, key)) child = shape.fields[key];
+		if (child === void 0 || isDeleteField(inner)) out[prefix + key] = inner;
+		else if (isReplace(inner)) out[prefix + key] = inner.value;
+		else yield* flatten(inner, child, `${prefix}${key}.`, out, options);
+	}
+	return out;
+});
+/**
+* The update of a document, out of the patch it takes, where the patch goes
+* one level down, and the paths it writes at.
+*/
+const updateOf = (patch, shape, paths) => {
+	const known = Schema.Struct(paths.known);
+	const patterns = [...paths.patterns.values()];
+	return (patterns.length === 0 ? known : Schema.StructWithRest(known, patterns)).pipe(Schema.decodeTo(Schema.toType(patch), {
+		decode: SchemaGetter.forbidden(() => "An update is only ever written, never read back"),
+		encode: SchemaGetter.transformEffect((value, options) => flatten(value, shape, "", {}, options))
+	}));
+};
+const update = (fields, mode) => {
+	const paths = emptyPaths();
+	const { patch, shape } = build(fields, [], paths, mode);
+	return updateOf(patch, shape, paths);
+};
+/**
+* The update of a document that is a union, patched at its Shared Fields - and,
+* unchecked, at a key only some members hold - by the rule a union field is
+* patched by. It is never written whole: a document changes member through
+* `set`.
+*/
+const unionUpdate = (members, mode) => {
+	const paths = emptyPaths();
+	const { patch, shape } = buildShared(members.map(fields), [], paths, mode);
+	return updateOf(patch, shape, paths);
+};
+/** @internal */
+const Class = (identifier) => (fields, annotations) => {
+	const Base = Variants.Class(identifier)(fields, annotations);
+	class Model extends Base {}
+	Object.defineProperty(Model, "update", { value: update(fields, "checked").annotate({
+		id: `${identifier}.update`,
+		title: `${identifier}.update`
+	}) });
+	Object.defineProperty(Model, "updateUnchecked", { value: update(fields, "unchecked").annotate({
+		id: `${identifier}.updateUnchecked`,
+		title: `${identifier}.updateUnchecked`
+	}) });
+	return Model;
+};
+/** @internal */
+const Immutable = (schema) => Field({
+	read: schema,
+	create: schema
+});
+/** @internal */
+const Timestamp = (schema) => Field({
+	read: schema,
+	create: ServerTimestampOr(schema),
+	update: ServerTimestampOr(schema)
+});
+/** @internal */
+const Number = (schema) => Field({
+	read: schema,
+	create: IncrementOr(schema),
+	update: IncrementOr(schema)
+});
+/** @internal */
+const Array$1 = (item) => Field({
+	read: Schema.Array(item),
+	create: Schema.Array(item),
+	update: ArrayOr(item)
+});
+const optionalField = fieldEvolve({
+	read: Schema.optionalKey,
+	create: Schema.optionalKey,
+	update: (schema) => Schema.optionalKey(DeleteFieldOr(schema))
+});
+/**
+* What a struct or a Record takes as a field of its own, which is what
+* `extract` hands back: the patches an unchecked update takes.
+*/
+const nodeUpdate = (node) => Schema.optionalKey(buildNode(node, [], emptyPaths(), "unchecked").schema);
+/** @internal */
+const Record = (key, value) => {
+	const { rest } = recordKeys(key);
+	const of = (variant) => {
+		const schema = variantSchema(value, variant);
+		return schema && Schema.Record(key, rest ? withoutOptionalKey(schema) : schema);
+	};
+	const read = of("read");
+	const create = of("create");
+	const node = recordNode(key, value, () => create, false);
+	return Object.assign(Field({
+		...read && { read },
+		...create && { create },
+		...node.writable && { update: nodeUpdate(node) }
+	}), { [RecordTypeId]: {
+		key,
+		value
+	} });
+};
+/** @internal */
+const Union = (members) => {
+	const read = Schema.Union(Variants.Union(members).members);
+	const node = unionNode(members, false);
+	const schemas = {
+		read,
+		create: node.create(),
+		...node.writable && { update: nodeUpdate(node) }
+	};
+	return Object.defineProperties(read, {
+		[FieldTypeId]: { value: FieldTypeId },
+		schemas: { value: schemas },
+		read: { value: Schema.Union(members.map((member) => extract(member, "read"))) },
+		create: { value: schemas.create },
+		update: { value: unionUpdate(members, "checked") },
+		updateUnchecked: { value: unionUpdate(members, "unchecked") },
+		[UnionTypeId]: { value: members }
+	});
+};
+const optionalNode = (self, node) => Field({
+	read: Schema.optionalKey(variantSchema(self, "read")),
+	create: Schema.optionalKey(node.create()),
+	...node.writable && { update: nodeUpdate(node) }
+});
+/** @internal */
+const Optional = (self) => {
+	if (isOptional(self)) return self;
+	const node = nodeOf(self, true);
+	return Object.assign(node === void 0 ? optionalField(self) : optionalNode(self, node), {
+		"~optionality": "optional",
+		field: self
+	});
+};
+export { Array$1 as Array, Class, Field, FieldExcept, FieldOnly, Immutable, Number, Optional, Record, RecordTypeId, Struct$1 as Struct, Timestamp, Union, UnionTypeId, extract, fieldEvolve, fields };