@efffrida/gplayapi 0.0.9 → 0.0.10

package/src/internal/auth.ts

@@ -1,15 +1,13 @@
-import type * as HttpClientError from "@effect/platform/HttpClientError";
-import type * as ParseResult from "effect/ParseResult";
+import type * as HttpClientError from "effect/unstable/http/HttpClientError";
 
-import * as HttpClient from "@effect/platform/HttpClient";
-import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
-import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
-import * as Layer from "effect/Layer";
 import * as Schema from "effect/Schema";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
+import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
 
-import type { Device } from "./device.ts";
+import type { AndroidDevice } from "./device.ts";
 
 import {
     AndroidCheckinRequestSchema,
@@ -19,13 +17,13 @@ import {
 import { decodeResponse, decodeResponseFromResponseWrapper, encodeRequest } from "./http.ts";
 
 /** @internal */
-export const makeHttpClient: (
-    device: Device
-) => Layer.Layer<
-    HttpClient.HttpClient,
-    HttpClientError.HttpClientError | ParseResult.ParseError,
+export const authHeaders = Effect.fn(function* (
+    device: AndroidDevice
+): Effect.fn.Return<
+    Record<string, string>,
+    HttpClientError.HttpClientError | Schema.SchemaError,
     HttpClient.HttpClient
-> = Effect.fnUntraced(function* (device: Device) {
+> {
     //  curl \
     //      --request GET \
     //      --header "Accept: application/json" \
@@ -185,37 +183,23 @@ export const makeHttpClient: (
     //     Effect.flatMap((response) => response.text)
     // );
 
-    return Layer.function(
-        HttpClient.HttpClient,
-        HttpClient.HttpClient,
-        Function.flow(
-            HttpClient.filterStatusOk,
-            HttpClient.mapRequest(
-                HttpClientRequest.updateUrl((url) =>
-                    url.startsWith("/fdfe/") ? `https://android.clients.google.com${url}` : url
-                )
-            ),
-            HttpClient.mapRequest(
-                HttpClientRequest.setHeaders({
-                    Authorization: "Bearer " + account.auth,
-                    "User-Agent": device.userAgent,
-                    "X-DFE-Device-Id": checkinResponse.androidId.toString(16),
-                    "Accept-Language": "en",
-                    "X-DFE-Encoded-Targets":
-                        "CAESN/qigQYC2AMBFfUbyA7SM5Ij/CvfBoIDgxHqGP8R3xzIBvoQtBKFDZ4HAY4FrwSVMasHBO0O2Q8akgYRAQECAQO7AQEpKZ0CnwECAwRrAQYBr9PPAoK7sQMBAQMCBAkIDAgBAwEDBAICBAUZEgMEBAMLAQEBBQEBAcYBARYED+cBfS8CHQEKkAEMMxcBIQoUDwYHIjd3DQ4MFk0JWGYZEREYAQOLAYEBFDMIEYMBAgICAgICOxkCD18LGQKEAcgDBIQBAgGLARkYCy8oBTJlBCUocxQn0QUBDkkGxgNZQq0BZSbeAmIDgAEBOgGtAaMCDAOQAZ4BBIEBKUtQUYYBQscDDxPSARA1oAEHAWmnAsMB2wFyywGLAxol+wImlwOOA80CtwN26A0WjwJVbQEJPAH+BRDeAfkHK/ABASEBCSAaHQemAzkaRiu2Ad8BdXeiAwEBGBUBBN4LEIABK4gB2AFLfwECAdoENq0CkQGMBsIBiQEtiwGgA1zyAUQ4uwS8AwhsvgPyAcEDF27vApsBHaICGhl3GSKxAR8MC6cBAgItmQYG9QIeywLvAeYBDArLAh8HASI4ELICDVmVBgsY/gHWARtcAsMBpALiAdsBA7QBpAJmIArpByn0AyAKBwHTARIHAX8D+AMBcRIBBbEDmwUBMacCHAciNp0BAQF0OgQLJDuSAh54kwFSP0eeAQQ4M5EBQgMEmwFXywFo0gFyWwMcapQBBugBPUW2AVgBKmy3AR6PAbMBGQxrUJECvQR+8gFoWDsYgQNwRSczBRXQAgtRswEW0ALMAREYAUEBIG6yATYCRE8OxgER8gMBvQEDRkwLc8MBTwHZAUOnAXiiBakDIbYBNNcCIUmuArIBSakBrgFHKs0EgwV/G3AD0wE6LgECtQJ4xQFwFbUCjQPkBS6vAQqEAUZF3QIM9wEhCoYCQhXsBCyZArQDugIziALWAdIBlQHwBdUErQE6qQaSA4EEIvYBHir9AQVLmgMCApsCKAwHuwgrENsBAjNYswEVmgIt7QJnN4wDEnta+wGfAcUBxgEtEFXQAQWdAUAeBcwBAQM7rAEJATJ0LENrdh73A6UBhAE+qwEeASxLZUMhDREuH0CGARbd7K0GlQo",
-                    "X-DFE-Phenotype":
-                        "H4sIAAAAAAAAAB3OO3KjMAAA0KRNuWXukBkBQkAJ2MhgAZb5u2GCwQZbCH_EJ77QHmgvtDtbv-Z9_H63zXXU0NVPB1odlyGy7751Q3CitlPDvFd8lxhz3tpNmz7P92CFw73zdHU2Ie0Ad2kmR8lxhiErTFLt3RPGfJQHSDy7Clw10bg8kqf2owLokN4SecJTLoSwBnzQSd652_MOf2d1vKBNVedzg4ciPoLz2mQ8efGAgYeLou-l-PXn_7Sna1MfhHuySxt-4esulEDp8Sbq54CPPKjpANW-lkU2IZ0F92LBI-ukCKSptqeq1eXU96LD9nZfhKHdtjSWwJqUm_2r6pMHOxk01saVanmNopjX3YxQafC4iC6T55aRbC8nTI98AF_kItIQAJb5EQxnKTO7TZDWnr01HVPxelb9A2OWX6poidMWl16K54kcu_jhXw-JSBQkVcD_fPsLSZu6joIBAAA",
-                    "X-DFE-Client-Id": "am-android-google",
-                    "X-DFE-Network-Type": "4",
-                    "X-DFE-Content-Filters": "",
-                    "X-Limit-Ad-Tracking-Enabled": "false",
-                    "X-Ad-Id": "",
-                    "X-DFE-UserLanguages": "en",
-                    "X-DFE-Request-Params": "timeoutMs=4000",
-                    "X-DFE-Device-Checkin-Consistency-Token": checkinResponse.deviceCheckinConsistencyToken,
-                    "X-DFE-Device-Config-Token": uploadDeviceConfigResponse.uploadDeviceConfigToken,
-                })
-            )
-        )
-    );
-}, Layer.unwrapEffect);
+    return {
+        Authorization: "Bearer " + account.auth,
+        "User-Agent": device.userAgent,
+        "X-DFE-Device-Id": checkinResponse.androidId.toString(16),
+        "Accept-Language": "en",
+        "X-DFE-Encoded-Targets":
+            "CAESN/qigQYC2AMBFfUbyA7SM5Ij/CvfBoIDgxHqGP8R3xzIBvoQtBKFDZ4HAY4FrwSVMasHBO0O2Q8akgYRAQECAQO7AQEpKZ0CnwECAwRrAQYBr9PPAoK7sQMBAQMCBAkIDAgBAwEDBAICBAUZEgMEBAMLAQEBBQEBAcYBARYED+cBfS8CHQEKkAEMMxcBIQoUDwYHIjd3DQ4MFk0JWGYZEREYAQOLAYEBFDMIEYMBAgICAgICOxkCD18LGQKEAcgDBIQBAgGLARkYCy8oBTJlBCUocxQn0QUBDkkGxgNZQq0BZSbeAmIDgAEBOgGtAaMCDAOQAZ4BBIEBKUtQUYYBQscDDxPSARA1oAEHAWmnAsMB2wFyywGLAxol+wImlwOOA80CtwN26A0WjwJVbQEJPAH+BRDeAfkHK/ABASEBCSAaHQemAzkaRiu2Ad8BdXeiAwEBGBUBBN4LEIABK4gB2AFLfwECAdoENq0CkQGMBsIBiQEtiwGgA1zyAUQ4uwS8AwhsvgPyAcEDF27vApsBHaICGhl3GSKxAR8MC6cBAgItmQYG9QIeywLvAeYBDArLAh8HASI4ELICDVmVBgsY/gHWARtcAsMBpALiAdsBA7QBpAJmIArpByn0AyAKBwHTARIHAX8D+AMBcRIBBbEDmwUBMacCHAciNp0BAQF0OgQLJDuSAh54kwFSP0eeAQQ4M5EBQgMEmwFXywFo0gFyWwMcapQBBugBPUW2AVgBKmy3AR6PAbMBGQxrUJECvQR+8gFoWDsYgQNwRSczBRXQAgtRswEW0ALMAREYAUEBIG6yATYCRE8OxgER8gMBvQEDRkwLc8MBTwHZAUOnAXiiBakDIbYBNNcCIUmuArIBSakBrgFHKs0EgwV/G3AD0wE6LgECtQJ4xQFwFbUCjQPkBS6vAQqEAUZF3QIM9wEhCoYCQhXsBCyZArQDugIziALWAdIBlQHwBdUErQE6qQaSA4EEIvYBHir9AQVLmgMCApsCKAwHuwgrENsBAjNYswEVmgIt7QJnN4wDEnta+wGfAcUBxgEtEFXQAQWdAUAeBcwBAQM7rAEJATJ0LENrdh73A6UBhAE+qwEeASxLZUMhDREuH0CGARbd7K0GlQo",
+        "X-DFE-Phenotype":
+            "H4sIAAAAAAAAAB3OO3KjMAAA0KRNuWXukBkBQkAJ2MhgAZb5u2GCwQZbCH_EJ77QHmgvtDtbv-Z9_H63zXXU0NVPB1odlyGy7751Q3CitlPDvFd8lxhz3tpNmz7P92CFw73zdHU2Ie0Ad2kmR8lxhiErTFLt3RPGfJQHSDy7Clw10bg8kqf2owLokN4SecJTLoSwBnzQSd652_MOf2d1vKBNVedzg4ciPoLz2mQ8efGAgYeLou-l-PXn_7Sna1MfhHuySxt-4esulEDp8Sbq54CPPKjpANW-lkU2IZ0F92LBI-ukCKSptqeq1eXU96LD9nZfhKHdtjSWwJqUm_2r6pMHOxk01saVanmNopjX3YxQafC4iC6T55aRbC8nTI98AF_kItIQAJb5EQxnKTO7TZDWnr01HVPxelb9A2OWX6poidMWl16K54kcu_jhXw-JSBQkVcD_fPsLSZu6joIBAAA",
+        "X-DFE-Client-Id": "am-android-google",
+        "X-DFE-Network-Type": "4",
+        "X-DFE-Content-Filters": "",
+        "X-Limit-Ad-Tracking-Enabled": "false",
+        "X-Ad-Id": "",
+        "X-DFE-UserLanguages": "en",
+        "X-DFE-Request-Params": "timeoutMs=4000",
+        "X-DFE-Device-Checkin-Consistency-Token": checkinResponse.deviceCheckinConsistencyToken,
+        "X-DFE-Device-Config-Token": uploadDeviceConfigResponse.uploadDeviceConfigToken,
+    };
+});

package/src/internal/device.ts

@@ -1,13 +1,37 @@
-import type * as PlatformError from "@effect/platform/Error";
-import type * as ParseResult from "effect/ParseResult";
+import type * as PlatformError from "effect/PlatformError";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import type * as HttpClientError from "effect/unstable/http/HttpClientError";
 
-import * as FileSystem from "@effect/platform/FileSystem";
 import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
 import * as Schema from "effect/Schema";
-import * as PropertiesFile from "properties-file";
+import * as SchemaGetter from "effect/SchemaGetter";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+
+import * as internalAuth from "./auth.ts";
+
+/** @internal */
+export const StringArrayFromString = Schema.suspend(() => {
+    const splitter = SchemaGetter.split({ separator: "," });
+    const joiner = SchemaGetter.transform((arr: ReadonlyArray<string>) => arr.join(","));
+    const transform = SchemaTransformation.make({ encode: joiner, decode: splitter });
+    return Schema.String.pipe(Schema.decodeTo(Schema.Array(Schema.String), transform));
+});
+
+/** @internal */
+export const BooleanFromString = Schema.Literals(["true", "false"]).pipe(
+    Schema.decodeTo(
+        Schema.Boolean,
+        SchemaTransformation.transform({
+            decode: (str) => str === "true",
+            encode: (bool) => (bool ? "true" : "false"),
+        })
+    )
+);
 
 /** @internal */
-export class Device extends Schema.Class<Device>("Device")({
+export class AndroidDevice extends Schema.Class<AndroidDevice>("AndroidDevice")({
     UserReadableName: Schema.String,
     "Build.BOOTLOADER": Schema.String,
     "Build.BRAND": Schema.String,
@@ -23,37 +47,22 @@ export class Device extends Schema.Class<Device>("Device")({
     "Build.VERSION.SDK_INT": Schema.NumberFromString,
     CellOperator: Schema.String,
     Client: Schema.String,
-    Features: Schema.transform(Schema.String, Schema.Array(Schema.String), {
-        encode: (features) => features.join(","),
-        decode: (str) => str.split(","),
-    }),
-    "GL.Extensions": Schema.transform(Schema.String, Schema.Array(Schema.String), {
-        encode: (extensions) => extensions.join(","),
-        decode: (str) => str.split(","),
-    }),
+    Features: StringArrayFromString,
+    "GL.Extensions": StringArrayFromString,
     "GL.Version": Schema.NumberFromString,
     "GSF.version": Schema.NumberFromString,
-    HasFiveWayNavigation: Schema.BooleanFromString,
-    HasHardKeyboard: Schema.BooleanFromString,
+    HasFiveWayNavigation: BooleanFromString,
+    HasHardKeyboard: BooleanFromString,
     Keyboard: Schema.NumberFromString,
-    Locales: Schema.transform(Schema.String, Schema.Array(Schema.String), {
-        encode: (locales) => locales.join(","),
-        decode: (str) => str.split(","),
-    }),
+    Locales: StringArrayFromString,
     Navigation: Schema.NumberFromString,
-    Platforms: Schema.transform(Schema.String, Schema.Array(Schema.String), {
-        encode: (libs) => libs.join(","),
-        decode: (str) => str.split(","),
-    }),
+    Platforms: StringArrayFromString,
     Roaming: Schema.String,
     "Screen.Density": Schema.NumberFromString,
     "Screen.Height": Schema.NumberFromString,
     "Screen.Width": Schema.NumberFromString,
     ScreenLayout: Schema.NumberFromString,
-    SharedLibraries: Schema.transform(Schema.String, Schema.Array(Schema.String), {
-        encode: (libs) => libs.join(","),
-        decode: (str) => str.split(","),
-    }),
+    SharedLibraries: StringArrayFromString,
     SimCountry: Schema.String.pipe(Schema.optional),
     SimOperator: Schema.String.pipe(Schema.optional),
     TimeZone: Schema.String,
@@ -61,16 +70,34 @@ export class Device extends Schema.Class<Device>("Device")({
     "Vending.version": Schema.NumberFromString,
     "Vending.versionString": Schema.String,
 }) {
-    public static fromPropertiesFile = (
-        path: string
-    ): Effect.Effect<Device, PlatformError.PlatformError | ParseResult.ParseError, FileSystem.FileSystem> =>
-        Effect.gen(function* () {
-            const fileSystem = yield* FileSystem.FileSystem;
-            const content = yield* fileSystem.readFileString(path);
-            const properties = PropertiesFile.getProperties(content);
-            const device = yield* Schema.decodeUnknown(Device)(properties);
-            return device;
-        });
+    private authHeadersCache?: Record<string, string> | undefined = undefined;
+
+    public static fromPropertiesFile = Effect.fnUntraced(function* (
+        file: string
+    ): Effect.fn.Return<AndroidDevice, Schema.SchemaError | PlatformError.PlatformError, FileSystem.FileSystem> {
+        const decodeDevice = Schema.decodeUnknownEffect(AndroidDevice);
+        const decodePropertiesFile = Schema.decodeEffect(
+            Schema.String.pipe(
+                Schema.decodeTo(
+                    Schema.Record(Schema.String, Schema.String),
+                    SchemaTransformation.splitKeyValue({
+                        keyValueSeparator: "=",
+                        separator: "\n",
+                    })
+                )
+            )
+        );
+
+        const fileSystem = yield* FileSystem.FileSystem;
+        const content = yield* fileSystem.readFileString(file);
+        const properties = yield* decodePropertiesFile(content);
+        return yield* decodeDevice(properties);
+    });
+
+    public static EmbeddedPixel7a = Path.Path.pipe(
+        Effect.flatMap((path) => path.fromFileUrl(new URL("../../devices/arm64_xxhdpi.properties", import.meta.url))),
+        Effect.flatMap(AndroidDevice.fromPropertiesFile)
+    );
 
     public get userAgent(): string {
         const deviceProperties = {
@@ -93,4 +120,18 @@ export class Device extends Schema.Class<Device>("Device")({
 
         return `Android-Finsky/${this["Vending.versionString"]} (${devicePropertiesString})`;
     }
+
+    public readonly authHeaders: Effect.Effect<
+        Record<string, string>,
+        HttpClientError.HttpClientError | Schema.SchemaError,
+        HttpClient.HttpClient
+    > = Effect.gen({ self: this }, function* () {
+        if (this.authHeadersCache) {
+            return this.authHeadersCache;
+        } else {
+            const authHeaders = yield* internalAuth.authHeaders(this);
+            this.authHeadersCache = authHeaders;
+            return this.authHeadersCache;
+        }
+    });
 }

package/src/internal/http.ts

@@ -1,10 +1,11 @@
-import * as Protobuf from "@bufbuild/protobuf";
-import * as HttpClientError from "@effect/platform/HttpClientError";
-import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
-import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
 import * as Predicate from "effect/Predicate";
+import * as HttpClientError from "effect/unstable/http/HttpClientError";
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
+import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
+
+import * as Protobuf from "@bufbuild/protobuf";
 
 import { type PayloadSchema, ResponseWrapperSchema } from "../generated/GooglePlay_pb.ts";
 
@@ -27,7 +28,7 @@ export const encodeRequest = Function.dual<
     ) => Effect.Effect<HttpClientRequest.HttpClientRequest, HttpClientError.HttpClientError, never>
 >(
     // Data first if the first argument is an http request
-    (arguments_) => Predicate.hasProperty(arguments_[0], HttpClientRequest.TypeId),
+    (arguments_: IArguments) => HttpClientRequest.isHttpClientRequest(arguments_[0]),
 
     // Body implementation
     Effect.fn("encodeRequest")(function* <Description extends Protobuf.DescMessage>(
@@ -47,11 +48,12 @@ export const encodeRequest = Function.dual<
                     options ?? { writeUnknownFields: true }
                 ),
             catch: (cause) =>
-                new HttpClientError.RequestError({
-                    cause,
-                    request,
-                    reason: "Encode",
-                    description: `Could not encode message of type ${messageType}`,
+                new HttpClientError.HttpClientError({
+                    reason: new HttpClientError.EncodeError({
+                        description: `Could not encode message of type ${messageType}`,
+                        request,
+                        cause,
+                    }),
                 }),
         });
 
@@ -77,7 +79,7 @@ export const decodeResponse = Function.dual<
     ) => Effect.Effect<Exclude<Protobuf.MessageShape<Desc>, undefined>, HttpClientError.HttpClientError, never>
 >(
     // Data first if the first argument is an http response
-    (arguments_) => Predicate.hasProperty(arguments_[0], HttpClientResponse.TypeId),
+    (arguments_: IArguments) => Predicate.hasProperty(arguments_[0], HttpClientResponse.TypeId),
 
     // Body implementation
     Effect.fn("decodeResponse")(function* <Desc extends Protobuf.DescMessage>(
@@ -97,21 +99,23 @@ export const decodeResponse = Function.dual<
                     options ?? { readUnknownFields: true }
                 ),
             catch: (cause) =>
-                new HttpClientError.ResponseError({
-                    cause,
-                    response,
-                    reason: "Decode",
-                    request: response.request,
-                    description: `Could not decode message of type ${messageType}`,
+                new HttpClientError.HttpClientError({
+                    reason: new HttpClientError.DecodeError({
+                        description: `Could not decode message of type ${messageType}`,
+                        request: response.request,
+                        response,
+                        cause,
+                    }),
                 }),
         });
 
         if (Predicate.isUndefined(message)) {
-            return yield* new HttpClientError.ResponseError({
-                response,
-                reason: "Decode",
-                request: response.request,
-                description: `Message of type ${messageType} is missing`,
+            return yield* new HttpClientError.HttpClientError({
+                reason: new HttpClientError.DecodeError({
+                    description: `Message of type ${messageType} is missing`,
+                    request: response.request,
+                    response,
+                }),
             });
         }
 
@@ -154,7 +158,7 @@ export const decodeResponseFromResponseWrapper = Function.dual<
     >
 >(
     // Data first if the first argument is an http response
-    (arguments_) => Predicate.hasProperty(arguments_[0], HttpClientResponse.TypeId),
+    (arguments_: IArguments) => Predicate.hasProperty(arguments_[0], HttpClientResponse.TypeId),
 
     // Body implementation
     Effect.fn("decodeResponse")(function* <
@@ -171,21 +175,23 @@ export const decodeResponseFromResponseWrapper = Function.dual<
         const responseWrapper = yield* decodeResponse(response, ResponseWrapperSchema, options);
 
         if (Predicate.isNotUndefined(responseWrapper.commands?.displayErrorMessage)) {
-            return yield* new HttpClientError.ResponseError({
-                response,
-                reason: "Decode",
-                request: response.request,
-                description: responseWrapper.commands.displayErrorMessage,
+            return yield* new HttpClientError.HttpClientError({
+                reason: new HttpClientError.DecodeError({
+                    description: responseWrapper.commands.displayErrorMessage,
+                    request: response.request,
+                    response,
+                }),
             });
         }
 
         const extracted = responseWrapper.payload?.[extractPayload];
         if (Predicate.isUndefined(extracted)) {
-            return yield* new HttpClientError.ResponseError({
-                response,
-                reason: "Decode",
-                request: response.request,
-                description: `ResponseWrapper has no payload of type ${extractPayload}`,
+            return yield* new HttpClientError.HttpClientError({
+                reason: new HttpClientError.DecodeError({
+                    description: `ResponseWrapper has no payload of type ${extractPayload}`,
+                    request: response.request,
+                    response,
+                }),
             });
         }