@visiolab/effect-firebase 0.0.0-stage → 0.3.1

package/src/firestore/internal/firestoreSchema.ts

@@ -0,0 +1,218 @@
+import {
+  Array,
+  Effect,
+  Equal,
+  Schema,
+  SchemaAST,
+  SchemaGetter,
+  SchemaIssue,
+  SchemaParser,
+  SchemaTransformation,
+} from "effect";
+import type * as Collection from "../Collection.ts";
+import type * as DocumentPath_ from "../DocumentPath.ts";
+import type * as FieldValue from "../FieldValue.ts";
+import type * as FirestoreSchema from "../FirestoreSchema.ts";
+import type * as GeoPoint_ from "../GeoPoint.ts";
+import * as collection_ from "./collection.ts";
+import * as documentPath from "./documentPath.ts";
+import * as fieldValue from "./fieldValue.ts";
+import * as firestoreValue from "./firestoreValue.ts";
+import * as geoPoint from "./geoPoint.ts";
+import * as timestampSchema from "./timestampSchema.ts";
+
+/** @internal */
+export const Timestamp: FirestoreSchema.Timestamp = timestampSchema.Timestamp;
+
+/** @internal */
+export const GeoPoint: FirestoreSchema.GeoPoint = Schema.declare<GeoPoint_.GeoPoint>(
+  geoPoint.isGeoPoint,
+  {
+    representation: { id: "@visiolab/effect-firebase/firestore/GeoPoint", payload: null },
+    expected: "a Firestore GeoPoint",
+    toEquivalence: () => Equal.equals,
+    toCodecFirestore: () => undefined,
+  },
+);
+
+/** @internal */
+export const DocumentPath: FirestoreSchema.DocumentPath =
+  Schema.declare<DocumentPath_.DocumentPath>(documentPath.isDocumentPath, {
+    representation: { id: "@visiolab/effect-firebase/firestore/DocumentPath", payload: null },
+    expected: "a Firestore document path",
+    toEquivalence: () => Equal.equals,
+    toCodecFirestore: () => undefined,
+  });
+
+/** @internal */
+export const DocumentReference = <C extends Collection.Any>(
+  collection: C,
+): FirestoreSchema.DocumentReference<C> => {
+  const pattern = collection_.pattern(collection);
+  return Schema.declare<Collection.DocumentReference<C>>(
+    (u): u is Collection.DocumentReference<C> =>
+      collection_.isDocumentReference(u) && u.collection === collection,
+    {
+      representation: {
+        id: "@visiolab/effect-firebase/firestore/DocumentReference",
+        payload: null,
+      },
+      expected: `a reference to a document in ${pattern}`,
+      toEquivalence: () => Equal.equals,
+      // Firestore stores the path alone, so reading one back checks it against
+      // `collection`'s segments and builds `collection`'s own reference.
+      toCodecFirestore: () =>
+        Schema.link<Collection.DocumentReference<C>>()(
+          DocumentPath.annotate({ expected: `a reference to a document in ${pattern}` }),
+          {
+            decode: SchemaGetter.transformEffect((value: DocumentPath_.DocumentPath, options) =>
+              Effect.fromOption(collection_.fromPath(collection, value.path)).pipe(
+                Effect.mapError(
+                  () =>
+                    new SchemaIssue.InvalidValue(
+                      { message: `Expected a document in ${pattern}, got "${value.path}"` },
+                      value,
+                      options,
+                    ),
+                ),
+              ),
+            ),
+            encode: SchemaGetter.transform((ref: Collection.DocumentReference<C>) =>
+              documentPath.makeUnchecked(ref.path),
+            ),
+          },
+        ),
+    },
+  );
+};
+
+/** @internal */
+export const ServerTimestamp: FirestoreSchema.ServerTimestamp =
+  Schema.declare<FieldValue.ServerTimestamp>(fieldValue.isServerTimestamp, {
+    representation: {
+      id: "@visiolab/effect-firebase/firestore/FieldValue/ServerTimestamp",
+      payload: null,
+    },
+    expected: "a server timestamp",
+    toCodecFirestore: () => undefined,
+  }).pipe(Schema.withConstructorDefault(Effect.succeed(fieldValue.serverTimestamp)));
+
+/** @internal */
+export const ServerTimestampOr = <S extends FirestoreSchema.TimeSchema>(
+  schema: S,
+): FirestoreSchema.ServerTimestampOr<S> => Schema.Union([schema, ServerTimestamp]);
+
+/** @internal */
+export const Increment: FirestoreSchema.Increment = Schema.declare<FieldValue.Increment>(
+  fieldValue.isIncrement,
+  {
+    representation: {
+      id: "@visiolab/effect-firebase/firestore/FieldValue/Increment",
+      payload: null,
+    },
+    expected: "an increment",
+    toEquivalence: () => Equal.equals,
+    toCodecFirestore: () => undefined,
+  },
+);
+
+/** @internal */
+export const IncrementOr = <S extends Schema.Codec<unknown, number, unknown, unknown>>(
+  schema: S,
+): FirestoreSchema.IncrementOr<S> => Schema.Union([schema, Increment]);
+
+/** @internal */
+export const DeleteField: FirestoreSchema.DeleteField = Schema.declare<FieldValue.DeleteField>(
+  fieldValue.isDeleteField,
+  {
+    representation: {
+      id: "@visiolab/effect-firebase/firestore/FieldValue/DeleteField",
+      payload: null,
+    },
+    expected: "a field deletion",
+    toCodecFirestore: () => undefined,
+  },
+);
+
+/** @internal */
+export const DeleteFieldOr = <S extends Schema.Top>(schema: S): FirestoreSchema.DeleteFieldOr<S> =>
+  Schema.Union([DeleteField, schema]);
+
+/**
+ * Declares a sentinel that carries elements, each of them run through `item` -
+ * decoded on the way in and encoded on the way out, as `Schema.Option` does
+ * with what it holds.
+ *
+ * Its Firestore form is the same sentinel, holding the elements in their own
+ * Firestore form: `toCodecFirestore` links it to a sentinel of `item`'s derived
+ * codec, so a `DateTimeUtc` among them is stored as a timestamp.
+ */
+const elementsSentinel = <Sentinel extends { readonly elements: ReadonlyArray<unknown> }>(
+  name: string,
+  is: (u: unknown) => u is Sentinel,
+  make: (...elements: ReadonlyArray<unknown>) => Sentinel,
+) => {
+  const declareSentinel = <S extends Schema.Top>(
+    item: S,
+    toCodecFirestore: (typeParameters: readonly [Schema.Top]) => SchemaAST.Link | undefined,
+  ) =>
+    Schema.declareConstructor<Sentinel, Sentinel>()(
+      [item],
+      ([item]) => {
+        const elements = Schema.Array(item);
+        return (input, ast, options) =>
+          is(input)
+            ? SchemaParser.decodeEffect(elements)(input.elements, options).pipe(
+                Effect.mapBothEager({
+                  onSuccess: (decoded) => make(...decoded),
+                  onFailure: (issue) => new SchemaIssue.Pointer(["elements"], issue),
+                }),
+              )
+            : Effect.fail(new SchemaIssue.InvalidType(ast, input, options));
+      },
+      {
+        representation: {
+          id: `@visiolab/effect-firebase/firestore/FieldValue/${name}`,
+          payload: null,
+        },
+        expected: `an ${name}`,
+        toCodecFirestore,
+        toEquivalence: ([item]) => {
+          const elements = Array.makeEquivalence(item);
+          return (self, that) => elements(self.elements, that.elements);
+        },
+      },
+    );
+  return <S extends Schema.Top>(item: S) =>
+    declareSentinel(item, ([encoded]) =>
+      Schema.link<Sentinel>()(
+        // Already in Firestore form, elements and all, so derivation leaves it.
+        declareSentinel(firestoreValue.toCodecFirestore(encoded), () => undefined),
+        SchemaTransformation.passthrough(),
+      ),
+    );
+};
+
+const ArrayUnionSentinel = elementsSentinel(
+  "ArrayUnion",
+  fieldValue.isArrayUnion,
+  fieldValue.arrayUnion,
+);
+
+/** @internal */
+export const ArrayUnion = <S extends Schema.Top>(item: S): FirestoreSchema.ArrayUnion<S> =>
+  ArrayUnionSentinel(item) as unknown as FirestoreSchema.ArrayUnion<S>;
+
+const ArrayRemoveSentinel = elementsSentinel(
+  "ArrayRemove",
+  fieldValue.isArrayRemove,
+  fieldValue.arrayRemove,
+);
+
+/** @internal */
+export const ArrayRemove = <S extends Schema.Top>(item: S): FirestoreSchema.ArrayRemove<S> =>
+  ArrayRemoveSentinel(item) as unknown as FirestoreSchema.ArrayRemove<S>;
+
+/** @internal */
+export const ArrayOr = <S extends Schema.Top>(item: S): FirestoreSchema.ArrayOr<S> =>
+  Schema.Union([Schema.Array(item), ArrayUnion(item), ArrayRemove(item)]);

package/src/firestore/internal/firestoreValue.ts

@@ -0,0 +1,202 @@
+import {
+  DateTime,
+  Effect,
+  Predicate,
+  Schema,
+  SchemaAST,
+  SchemaGetter,
+  SchemaIssue,
+  SchemaTransformation,
+} from "effect";
+import type * as FirestoreValue from "../FirestoreValue.ts";
+import type * as Timestamp_ from "../Timestamp.ts";
+import * as firestoreValueWalk from "./firestoreValueWalk.ts";
+import * as schemaAST from "./schemaAST.ts";
+import * as timestamp from "./timestamp.ts";
+import * as timestampSchema from "./timestampSchema.ts";
+
+/** @internal */
+export const isFirestoreValue = firestoreValueWalk.isFirestoreValue;
+
+/**
+ * Accepts only Firestore Values. A declaration with no link to any canonical
+ * format falls back to this, so a value Firestore cannot store fails at its own
+ * path instead of being stored as a map.
+ */
+const FirestoreValueSchema = Schema.declare<FirestoreValue.FirestoreValue>(isFirestoreValue, {
+  expected: "a Firestore value",
+  toCodecFirestore: () => undefined,
+});
+
+/** @internal */
+export const unknownToFirestore = new SchemaAST.Link(
+  FirestoreValueSchema.ast,
+  SchemaTransformation.passthrough(),
+);
+
+const timestampFromMillis = (millis: number, options: SchemaAST.ParseOptions) => {
+  const out = timestamp.fromMillis(millis);
+  return out._tag === "Some"
+    ? Effect.succeed(out.value)
+    : Effect.fail(
+        new SchemaIssue.InvalidValue(
+          { message: "Expected an instant Firestore can store, between the years 1 and 9999" },
+          millis,
+          options,
+        ),
+      );
+};
+
+const dateToTimestamp = Schema.link<globalThis.Date>()(timestampSchema.Timestamp, {
+  decode: SchemaGetter.transform((ts: Timestamp_.Timestamp) => new Date(timestamp.toMillis(ts))),
+  encode: SchemaGetter.transformEffect((date: globalThis.Date, options) =>
+    timestampFromMillis(date.getTime(), options),
+  ),
+});
+
+const dateTimeUtcToTimestamp = Schema.link<DateTime.Utc>()(timestampSchema.Timestamp, {
+  decode: SchemaGetter.transform(timestamp.toDateTime),
+  encode: SchemaGetter.transformEffect((dateTime: DateTime.Utc, options) =>
+    timestampFromMillis(DateTime.toEpochMillis(dateTime), options),
+  ),
+});
+
+const representationId = (ast: SchemaAST.Declaration): unknown => {
+  const representation: unknown = ast.annotations?.representation;
+  return Predicate.hasProperty(representation, "id") ? representation.id : undefined;
+};
+
+/**
+ * Firestore's own types come first, so these win over the declaration's
+ * `toCodecJson`, which would write a string.
+ */
+const nativeLink = (ast: SchemaAST.Declaration): SchemaAST.Link | null | undefined => {
+  switch (representationId(ast)) {
+    case "effect/schema/Date":
+      return dateToTimestamp;
+    case "effect/schema/DateTimeUtc":
+      return dateTimeUtcToTimestamp;
+    case "effect/schema/Uint8Array":
+      return null;
+  }
+  return undefined;
+};
+
+type GetLink = (typeParameters: ReadonlyArray<Schema.Constraint>) => SchemaAST.Link | undefined;
+
+const declarationStep = (
+  ast: SchemaAST.Declaration,
+  recur: (ast: SchemaAST.AST) => SchemaAST.AST,
+): SchemaAST.AST => {
+  const native = nativeLink(ast);
+  if (native === null) return ast;
+  if (native !== undefined) return schemaAST.replaceEncoding(ast, [native]);
+  const annotations = ast.annotations as
+    | {
+        readonly toCodecFirestore?: unknown;
+        readonly toCodecJson?: unknown;
+        readonly toCodec?: unknown;
+      }
+    | undefined;
+  const getLink = [
+    annotations?.toCodecFirestore,
+    annotations?.toCodecJson,
+    annotations?.toCodec,
+  ].find(Predicate.isFunction) as GetLink | undefined;
+  if (getLink === undefined) return schemaAST.replaceEncoding(ast, [unknownToFirestore]);
+  const typeParameters = ast.typeParameters.map((tp) => Schema.make(SchemaAST.toEncoded(tp)));
+  const link = getLink(typeParameters);
+  // `undefined` means the declaration is already canonical, and so is
+  // everything it holds: in Firestore form, or in JSON form, and every JSON
+  // value is a Firestore Value.
+  return link === undefined
+    ? ast
+    : schemaAST.replaceEncoding(ast, [schemaAST.mapLink(link, recur)]);
+};
+
+const reorderUnion = (types: ReadonlyArray<SchemaAST.AST>): ReadonlyArray<SchemaAST.AST> => {
+  // Members written as strings go first, so a string member doesn't swallow
+  // them when reading back, as `toCodecJson` does.
+  const priority = (ast: SchemaAST.AST): number => {
+    switch (SchemaAST.toEncoded(ast)._tag) {
+      case "BigInt":
+      case "Symbol":
+      case "UniqueSymbol":
+        return 0;
+      default:
+        return 1;
+    }
+  };
+  const sorted = [...types].sort((a, b) => priority(a) - priority(b));
+  return sorted.some((ast, i) => ast !== types[i]) ? sorted : types;
+};
+
+const step = (ast: SchemaAST.AST, recur: (ast: SchemaAST.AST) => SchemaAST.AST): SchemaAST.AST => {
+  switch (ast._tag) {
+    case "Declaration":
+      return declarationStep(ast, recur);
+    // Unlike `Schema.toCodecJson`, `Schema.Any` is no escape hatch: the SDK
+    // mappings take Firestore Values only, so nothing else may get past here.
+    case "Any":
+    case "Unknown":
+    case "ObjectKeyword":
+      return schemaAST.replaceEncoding(ast, [unknownToFirestore]);
+    case "Undefined":
+    case "Void":
+    case "Literal":
+      return schemaAST.keywordToCodecJson(ast);
+    case "UniqueSymbol":
+    case "Symbol":
+    case "BigInt":
+      return schemaAST.keywordToCodecStringTree(ast);
+    case "Objects":
+      // A map's keys are strings, so a struct keyed by a symbol has no
+      // Firestore form. Derivation never fails: the struct takes Firestore
+      // Values only, and encoding one fails with a schema issue at its path.
+      if (ast.propertySignatures.some((ps) => typeof ps.name !== "string")) {
+        return schemaAST.replaceEncoding(ast, [unknownToFirestore]);
+      }
+      return schemaAST.recur(ast, recur, schemaAST.parameterFromString);
+    case "Union": {
+      const types = reorderUnion(ast.types);
+      const union =
+        types === ast.types
+          ? ast
+          : new SchemaAST.Union(
+              types,
+              ast.options,
+              ast.annotations,
+              ast.checks,
+              ast.encoding,
+              ast.context,
+              ast.encodingChecks,
+            );
+      return schemaAST.recur(union, recur);
+    }
+    case "Arrays":
+    case "Suspend":
+      return schemaAST.recur(ast, recur);
+  }
+  // `null`, `boolean`, `number` and `string` are already Firestore Values.
+  return ast;
+};
+
+const withoutConstructorDefault = (context: SchemaAST.Context): SchemaAST.Context =>
+  context.constructorDefault === undefined
+    ? context
+    : new SchemaAST.Context(context.isOptional, context.isMutable, undefined, context.annotations);
+
+/** @internal */
+export const toCodecFirestoreAST: (ast: SchemaAST.AST) => SchemaAST.AST =
+  schemaAST.applyToSelfOrLastLinkEncodingIdempotent((ast) => {
+    const out = step(ast, toCodecFirestoreAST);
+    const context = ast.context;
+    if (out === ast || context === undefined) return out;
+    return schemaAST.replaceContextLastLink(out, withoutConstructorDefault(context));
+  });
+
+/** @internal */
+export const toCodecFirestore = <S extends Schema.Constraint>(
+  schema: S,
+): FirestoreValue.toCodecFirestore<S> =>
+  Schema.make<FirestoreValue.toCodecFirestore<S>>(toCodecFirestoreAST(schema.ast), { schema });