firestore-proto-codec 0.2.0 → 0.3.0

package/README.md

@@ -45,34 +45,35 @@ int64; decoding hands them back as strings.
 ## Binding to an SDK
 
 The default adapter emits dependency-free `FsTimestamp` / `FsBlob` /
-`FsGeoPoint`. Supply your own to write straight to Firestore:
+`FsGeoPoint`, which the admin SDK refuses outright: it rejects custom
+prototypes, so a forgotten adapter throws at the write and stores nothing.
+
+For `firebase-admin` / `@google-cloud/firestore`, the adapter ships:
 
 ```ts
-class AdminTypes implements FirestoreTypes {
-  timestamp = (seconds: bigint, nanos: number) =>
-    new Timestamp(Number(seconds), nanos);
-  blob = (bytes: Uint8Array) => Buffer.from(bytes);
-  geoPoint = (lat: number, lng: number) => new GeoPoint(lat, lng);
-
-  readTimestamp = (v: unknown) =>
-    v instanceof Timestamp
-      ? { seconds: BigInt(v.seconds), nanos: v.nanoseconds }
-      : undefined;
-  // Buffer extends Uint8Array, so this covers both.
-  readBlob = (v: unknown) =>
-    v instanceof Uint8Array ? new Uint8Array(v) : undefined;
-  readGeoPoint = (v: unknown) =>
-    v instanceof GeoPoint
-      ? { latitude: v.latitude, longitude: v.longitude }
-      : undefined;
-}
-
-const codec = new FirestoreProtoCodec(new AdminTypes());
+import { adminCodec } from "firestore-proto-codec/admin";
+
+await doc.set(adminCodec.encode(TaskSchema, task));
 ```
 
-Verified against `@google-cloud/firestore` 9.0.1: there is no `Bytes` class in
-the admin SDK (that one belongs to the web client SDK), and bytes values are
-plain `Buffer`s.
+`AdminFirestoreTypes` comes from the same subpath if you would rather construct
+the codec yourself. `@google-cloud/firestore` is an **optional peer
+dependency** — only that subpath imports it, so the root entry point still
+carries no Firebase dependency. `firebase-admin` already depends on it, so a
+hoisted layout resolves it with nothing added; a strict one (pnpm, Yarn PnP)
+needs `@google-cloud/firestore` in your own dependencies.
+
+Its reads are structural rather than `instanceof`. The codec only calls them at
+a position the schema has already declared a `Timestamp`, `bytes` or `LatLng`,
+so there is no type to discriminate and nothing to lose — and a structural
+check survives two copies of `@google-cloud/firestore` in the tree, which would
+otherwise make `instanceof` false and fail every read with
+`expected a timestamp`.
+
+For any other SDK, implement `FirestoreTypes` yourself; [src/admin.ts](src/admin.ts)
+is the worked example. Verified against `@google-cloud/firestore` 9.0.1: there
+is no `Bytes` class in the admin SDK (that one belongs to the web client SDK),
+and bytes values are plain `Buffer`s.
 
 Keeping this an interface is why the core has no Firebase dependency.
 
@@ -164,8 +165,9 @@ It needs a JDK 21 or newer, which the Firestore emulator requires;
 `firebase-tools` is fetched by the script at a pinned version, so the emulator
 build is the same one CI runs. The suite is skipped when
 `FIRESTORE_EMULATOR_HOST` is unset, so `npm test` stays green without a JDK.
-`@google-cloud/firestore` is a dev dependency only -- the published package
-still has no Firebase dependency.
+`@google-cloud/firestore` is a dev dependency and an optional peer -- nothing
+but the `/admin` subpath imports it, so the root entry point has no Firebase
+dependency.
 
 Nothing in a pull request can change what the server does, so CI runs this
 [weekly](../.github/workflows/emulator.yml) rather than per-PR, and it can be

package/dist/admin.d.ts

@@ -0,0 +1,28 @@
+import { FirestoreProtoCodec } from "./codec.js";
+import type { FirestoreTypes } from "./values.js";
+/**
+ * The reads are structural rather than `instanceof`. They can afford to be:
+ * the codec never uses them to discriminate a type, only to unwrap a value at
+ * a position the schema has already declared a `Timestamp`, `bytes` or
+ * `LatLng`, so a loose check cannot misclassify anything. What it buys is
+ * immunity to two copies of `@google-cloud/firestore` in the tree -- a
+ * version-range accident a consumer does not control, which makes `instanceof`
+ * false and turns every read into `expected a timestamp`. That failure reads
+ * like data corruption rather than like a dependency problem.
+ */
+export declare class AdminFirestoreTypes implements FirestoreTypes {
+    timestamp(seconds: bigint, nanos: number): unknown;
+    blob(bytes: Uint8Array): unknown;
+    geoPoint(latitude: number, longitude: number): unknown;
+    readTimestamp(value: unknown): {
+        seconds: bigint;
+        nanos: number;
+    } | undefined;
+    readBlob(value: unknown): Uint8Array | undefined;
+    readGeoPoint(value: unknown): {
+        latitude: number;
+        longitude: number;
+    } | undefined;
+}
+/** Shared instance: the codec keeps no per-call state. */
+export declare const adminCodec: FirestoreProtoCodec;

package/dist/admin.js

@@ -0,0 +1,70 @@
+/**
+ * `FirestoreTypes` for the Firestore Admin SDK. `firebase-admin/firestore` and
+ * `@google-cloud/firestore` re-export the same `Timestamp` and `GeoPoint`, so
+ * this adapter serves both.
+ *
+ * ```ts
+ * import { adminCodec } from "firestore-proto-codec/admin";
+ * ```
+ *
+ * Not a convenience: without an adapter the codec emits `FsTimestamp` /
+ * `FsBlob` / `FsGeoPoint`, and the admin SDK refuses a custom prototype
+ * outright, so the write throws and stores nothing (pinned by
+ * test/emulator.test.ts). Every admin consumer needs this, which is why it
+ * ships here rather than being copied out of the README.
+ *
+ * `@google-cloud/firestore` is an optional peer dependency. Only this module
+ * imports it -- the root entry point stays dependency-free.
+ */
+import { GeoPoint, Timestamp } from "@google-cloud/firestore";
+import { FirestoreProtoCodec } from "./codec.js";
+/**
+ * The reads are structural rather than `instanceof`. They can afford to be:
+ * the codec never uses them to discriminate a type, only to unwrap a value at
+ * a position the schema has already declared a `Timestamp`, `bytes` or
+ * `LatLng`, so a loose check cannot misclassify anything. What it buys is
+ * immunity to two copies of `@google-cloud/firestore` in the tree -- a
+ * version-range accident a consumer does not control, which makes `instanceof`
+ * false and turns every read into `expected a timestamp`. That failure reads
+ * like data corruption rather than like a dependency problem.
+ */
+export class AdminFirestoreTypes {
+    timestamp(seconds, nanos) {
+        // Firestore spans years 1--9999, so seconds stays far inside
+        // Number.MAX_SAFE_INTEGER and the narrowing is lossless.
+        return new Timestamp(Number(seconds), nanos);
+    }
+    blob(bytes) {
+        // Copies rather than viewing `bytes.buffer`: a pending write must not
+        // change under a caller who mutates the message after encoding it.
+        return Buffer.from(bytes);
+    }
+    geoPoint(latitude, longitude) {
+        return new GeoPoint(latitude, longitude);
+    }
+    readTimestamp(value) {
+        const ts = value;
+        return typeof ts?.seconds === "number" &&
+            typeof ts?.nanoseconds === "number" &&
+            typeof ts?.toDate === "function"
+            ? { seconds: BigInt(ts.seconds), nanos: ts.nanoseconds }
+            : undefined;
+    }
+    readBlob(value) {
+        // `instanceof` is right here, unlike above: `Uint8Array` is a realm
+        // intrinsic, not a package export, so a duplicated dependency cannot
+        // detach it. The copy hands the decoded message a plain `Uint8Array`
+        // rather than the SDK's `Buffer`, which a strict deep-equal against an
+        // encoded message would otherwise report as a type mismatch.
+        return value instanceof Uint8Array ? new Uint8Array(value) : undefined;
+    }
+    readGeoPoint(value) {
+        const point = value;
+        return typeof point?.latitude === "number" &&
+            typeof point?.longitude === "number"
+            ? { latitude: point.latitude, longitude: point.longitude }
+            : undefined;
+    }
+}
+/** Shared instance: the codec keeps no per-call state. */
+export const adminCodec = new FirestoreProtoCodec(new AdminFirestoreTypes());

package/dist/values.d.ts

@@ -1,8 +1,13 @@
 /**
  * Firestore has three value types protobuf cannot express as plain data.
  * Implement this to bind them to a particular SDK's classes -- `Timestamp`,
- * `Bytes`, and `GeoPoint` in `firebase-admin`, for example. Everything else in
- * the encoding is a plain string, number, bigint, boolean, array, or object.
+ * `Buffer`, and `GeoPoint` in `firebase-admin`, for example. (Bytes are plain
+ * `Buffer`s there; the `Bytes` class belongs to the web client SDK.)
+ * Everything else in the encoding is a plain string, number, bigint, boolean,
+ * array, or object.
+ *
+ * The admin implementation ships as `firestore-proto-codec/admin`. Write your
+ * own only for another SDK.
  */
 export interface FirestoreTypes {
     timestamp(seconds: bigint, nanos: number): unknown;
@@ -34,8 +39,9 @@ export declare class FsGeoPoint {
     readonly longitude: number;
     constructor(latitude: number, longitude: number);
 }
-/** Dependency-free default. Swap in an SDK-specific implementation to write
- * directly to Firestore. */
+/** Dependency-free default. It cannot write to Firestore: the admin SDK
+ * refuses these custom prototypes outright. Swap in an SDK-specific
+ * implementation -- `firestore-proto-codec/admin` for firebase-admin. */
 export declare class DefaultFirestoreTypes implements FirestoreTypes {
     timestamp(seconds: bigint, nanos: number): unknown;
     blob(bytes: Uint8Array): unknown;

package/dist/values.js

@@ -20,8 +20,9 @@ export class FsGeoPoint {
         this.longitude = longitude;
     }
 }
-/** Dependency-free default. Swap in an SDK-specific implementation to write
- * directly to Firestore. */
+/** Dependency-free default. It cannot write to Firestore: the admin SDK
+ * refuses these custom prototypes outright. Swap in an SDK-specific
+ * implementation -- `firestore-proto-codec/admin` for firebase-admin. */
 export class DefaultFirestoreTypes {
     timestamp(seconds, nanos) {
         return new FsTimestamp(seconds, nanos);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firestore-proto-codec",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Encode a protobuf message as a Firestore value, and decode it back.",
   "license": "Apache-2.0",
   "repository": {
@@ -16,6 +16,10 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./admin": {
+      "types": "./dist/admin.d.ts",
+      "default": "./dist/admin.js"
+    },
     "./proto/*": "./proto/*"
   },
   "files": [
@@ -34,6 +38,14 @@
   "dependencies": {
     "@bufbuild/protobuf": "^2.2.0"
   },
+  "peerDependencies": {
+    "@google-cloud/firestore": ">=6"
+  },
+  "peerDependenciesMeta": {
+    "@google-cloud/firestore": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@bufbuild/protoc-gen-es": "^2.2.0",
     "@google-cloud/firestore": "^9.0.1",