graze-client 0.8.0 → 0.9.0

package/src/GrazeClient.ts

@@ -1,3 +1,4 @@
+import { Config, Context, Data, Effect, Layer, Redacted, Schema } from "effect";
 import {
   AlgoUpdateResponse,
   GetAlgoResponse,
@@ -5,21 +6,18 @@ import {
   HidePostBody,
   UnhidePostBody,
 } from "./schema/shared.js";
-import {
-  FetchHttpClient,
-  HttpApi,
-  HttpApiClient,
-  HttpApiEndpoint,
-  HttpApiGroup,
-  HttpApiSchema,
-  HttpClient,
-  HttpClientRequest,
-} from "@effect/platform";
-import { Config, Data, Effect, Redacted, Schema } from "effect";
 
-import * as Form from "./schema/UpdateAlgorithmPayload.js";
 import { FeedIdParam, UserIdParam } from "./common.js";
+import * as Form from "./schema/UpdateAlgorithmPayload.js";
 import { StickyPostsApiGroup } from "./stickyposts.js";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as HttpApi from "effect/unstable/httpapi/HttpApi";
+import * as HttpApiClient from "effect/unstable/httpapi/HttpApiClient";
+import * as HttpApiEndpoint from "effect/unstable/httpapi/HttpApiEndpoint";
+import * as HttpApiGroup from "effect/unstable/httpapi/HttpApiGroup";
+import * as HttpApiSchema from "effect/unstable/httpapi/HttpApiSchema";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
 
 function isStringOrBlob(val: unknown): val is string | Blob {
   return typeof val === "string" || val instanceof Blob;
@@ -27,10 +25,10 @@ function isStringOrBlob(val: unknown): val is string | Blob {
 
 const encodeForm = (obj: Form.FullForm) =>
   Effect.gen(function* () {
-    const encoded = yield* Schema.encode(Form.FullForm)(obj);
+    const encoded = yield* Schema.encodeEffect(Form.FullForm)(obj);
     const formData = new FormData();
     for (const key in encoded) {
-      if (encoded.hasOwnProperty(key)) {
+      if (Object.prototype.hasOwnProperty.call(encoded, key)) {
         const val = encoded[key as keyof Form.FullForm];
         if (isStringOrBlob(val)) {
           formData.append(key, val);
@@ -42,44 +40,49 @@ const encodeForm = (obj: Form.FullForm) =>
 
 const GrazeApiGroup = HttpApiGroup.make("graze", { topLevel: true })
   .add(
-    HttpApiEndpoint.get("getFeeds")`/app/my_feeds`
-      .addSuccess(GetAlgorithmsResponse)
-      .setPayload(
-        Schema.Struct({
-          user_id: UserIdParam,
-        })
-      )
+    HttpApiEndpoint.get("getFeeds", "/app/my_feeds", {
+      // v3 GET `setPayload` serialised to query params (GET has no body); v4
+      // expresses that as `query`.
+      query: Schema.Struct({
+        user_id: UserIdParam,
+      }),
+      success: GetAlgorithmsResponse,
+    }),
   )
   .add(
-    HttpApiEndpoint.get("getFeed")`/app/my_feeds/${FeedIdParam}`.addSuccess(
-      GetAlgoResponse
-    )
+    HttpApiEndpoint.get("getFeed", "/app/my_feeds/:feedId", {
+      params: { feedId: FeedIdParam },
+      success: GetAlgoResponse,
+    }),
   )
   .add(
-    HttpApiEndpoint.post("updateAlgorithm")`/app/edit_algo_image`
-      .setPayload(HttpApiSchema.Multipart(Form.FullForm))
-      .addSuccess(AlgoUpdateResponse)
+    HttpApiEndpoint.post("updateAlgorithm", "/app/edit_algo_image", {
+      payload: Form.FullForm.pipe(HttpApiSchema.asMultipart()),
+      success: AlgoUpdateResponse,
+    }),
   )
   .add(
-    HttpApiEndpoint.get(
-      "publishAlgorithm"
-    )`/app/publish_algo/${FeedIdParam}`.addSuccess(Schema.Unknown)
+    HttpApiEndpoint.get("publishAlgorithm", "/app/publish_algo/:feedId", {
+      params: { feedId: FeedIdParam },
+      success: Schema.Unknown,
+    }),
   )
   .add(
-    HttpApiEndpoint.post("hidePost")`/app/hide_post`
-      .setPayload(HidePostBody)
-      .addSuccess(Schema.Unknown)
+    HttpApiEndpoint.post("hidePost", "/app/hide_post", {
+      payload: HidePostBody,
+      success: Schema.Unknown,
+    }),
   )
   .add(
-    HttpApiEndpoint.post("unhidePost")`/app/unhide_post`
-      .setPayload(UnhidePostBody)
-      .addSuccess(Schema.Unknown)
+    HttpApiEndpoint.post("unhidePost", "/app/unhide_post", {
+      payload: UnhidePostBody,
+      success: Schema.Unknown,
+    }),
   );
 
 class GrazeApiDef extends HttpApi.make("grazeApi")
   .add(GrazeApiGroup)
-  .add(StickyPostsApiGroup)
-  .addError(Schema.Unknown) {}
+  .add(StickyPostsApiGroup) {}
 
 const grazeLive = Effect.gen(function* () {
   const baseUrl = yield* Config.url("GRAZE_API_URL");
@@ -93,8 +96,8 @@ const grazeLive = Effect.gen(function* () {
         HttpClient.mapRequest(
           HttpClientRequest.setHeaders({
             cookie: Redacted.value(cookie),
-          })
-        )
+          }),
+        ),
       ),
   });
 
@@ -104,8 +107,8 @@ const grazeLive = Effect.gen(function* () {
       return yield* client.updateAlgorithm({ payload: formData });
     });
 
-  const userId = yield* Config.integer("GRAZE_USER_ID");
-  const getFeeds = () => client.getFeeds({ payload: { user_id: userId } });
+  const userId = yield* Config.int("GRAZE_USER_ID");
+  const getFeeds = () => client.getFeeds({ query: { user_id: userId } });
 
   return {
     ...client,
@@ -114,13 +117,18 @@ const grazeLive = Effect.gen(function* () {
   };
 });
 
-export class GrazeClient extends Effect.Service<GrazeClient>()("GrazeClient", {
-  effect: grazeLive,
-  dependencies: [FetchHttpClient.layer],
-}) {
-  // TODO: test service
+export class GrazeClient extends Context.Service<
+  GrazeClient,
+  Effect.Success<typeof grazeLive>
+>()("GrazeClient") {
+  static readonly layer = Layer.effect(GrazeClient, grazeLive).pipe(
+    Layer.provide(FetchHttpClient.layer),
+  );
 }
 
+/** The resolved service shape (v4 has no `.Service` namespace on the tag). */
+export type GrazeClientService = Effect.Success<typeof grazeLive>;
+
 export class GrazeError extends Data.TaggedError("GrazeError")<{
   message: string;
   status: number;

package/src/builder.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   AttributeComparison,
   AttributeName,
   AttributeValue,
@@ -18,8 +18,8 @@ const neverMatch: Filter = {
   or: [],
 };
 
-const and = (...filters: (Filter | null)[]): Filter => {
-  const flatFilters: Filter[] = [];
+const and = (...filters: Array<Filter | null>): Filter => {
+  const flatFilters: Array<Filter> = [];
   filters.forEach((f) => {
     if (f === null) {
       // if the filter is null, we never want to match this block.
@@ -33,8 +33,8 @@ const and = (...filters: (Filter | null)[]): Filter => {
   });
   return { and: flatFilters };
 };
-const or = (...filters: (Filter | null)[]): Filter => {
-  const flatFilters: Filter[] = [];
+const or = (...filters: Array<Filter | null>): Filter => {
+  const flatFilters: Array<Filter> = [];
   filters
     .filter((f) => f !== null)
     .forEach((f) => {
@@ -49,26 +49,26 @@ const or = (...filters: (Filter | null)[]): Filter => {
 
 const regexMatches = (
   attribute: RegexMatches["regex_matches"][0],
-  regex: string
+  regex: string,
 ): RegexMatches => ({
   regex_matches: [attribute, regex, true],
 });
 
 const regexNegationMatches = (
   attribute: RegexNegationMatches["regex_negation_matches"][0],
-  regex: string
+  regex: string,
 ): RegexNegationMatches => ({
   regex_negation_matches: [attribute, regex, true],
 });
 
 const textMatchesAny = ({
   attribute,
-  patterns,
   caseInsensitive = true,
+  patterns,
   useRegex = false,
 }: {
   attribute: AttributeName;
-  patterns: string[];
+  patterns: Array<string>;
   caseInsensitive?: boolean;
   useRegex?: boolean;
 }): TextMatchesAny => ({
@@ -77,12 +77,12 @@ const textMatchesAny = ({
 
 const textMatchesNone = ({
   attribute,
-  patterns,
   caseInsensitive = true,
+  patterns,
   useRegex = false,
 }: {
   attribute: AttributeName;
-  patterns: string[];
+  patterns: Array<string>;
   caseInsensitive?: boolean;
   useRegex?: boolean;
 }): TextMatchesNone => ({
@@ -98,7 +98,7 @@ const isNotListMember = (uri: string): ListMemberFilter => ({
 const socialGraph = (
   identifier: string,
   op: SocialGraph["social_graph"][1],
-  relation: SocialGraph["social_graph"][2]
+  relation: SocialGraph["social_graph"][2],
 ): SocialGraph => ({
   social_graph: [identifier, op, relation],
 });
@@ -133,7 +133,7 @@ const hasNoNSFWLabels: Filter = {
 const attributeCompare = (
   attr: AttributeName,
   op: AttributeComparison,
-  value: AttributeValue
+  value: AttributeValue,
 ): Filter => ({
   attribute_compare: [attr, op, value],
 });
@@ -149,7 +149,7 @@ const isContentOk = (threshold: number = 0.9): ContentModerationBlock => ({
 });
 
 export const Algo = {
-  filter: (...filters: Filter[]): { filter: Filter } => ({
+  filter: (...filters: Array<Filter>): { filter: Filter } => ({
     filter: and(...filters),
   }),
 };

package/src/common.ts

@@ -1,11 +1,6 @@
-import { HttpApiSchema } from "@effect/platform";
 import { Schema } from "effect";
 
-export const UserIdParam = HttpApiSchema.param(
-  "userId",
-  Schema.NumberFromString
-);
-export const FeedIdParam = HttpApiSchema.param(
-  "feedId",
-  Schema.NumberFromString
-);
+// v4 has no `HttpApiSchema.param`: path params are declared inline in the
+// endpoint path (`:feedId`) with a `params: { feedId: FeedIdParam }` schema map.
+export const UserIdParam = Schema.NumberFromString;
+export const FeedIdParam = Schema.NumberFromString;

package/src/index.ts

@@ -1,24 +1,24 @@
-import { ConfigProvider, Effect, Layer } from "effect";
-import { GrazeClient } from "./GrazeClient.js";
+import { ConfigProvider, Effect } from "effect";
+import { GrazeClient, type GrazeClientService } from "./GrazeClient.js";
 
 type Promisify<T> = T extends (
-  ...args: any[]
-) => Effect.Effect<infer A, infer E, never>
+  ...args: Array<any>
+) => Effect.Effect<infer A, infer _E, never>
   ? (...args: Parameters<T>) => Promise<A>
   : never;
 
 export class GrazeService {
-  getFeed: Promisify<typeof GrazeClient.Service.getFeed>;
-  getFeeds: Promisify<typeof GrazeClient.Service.getFeeds>;
-  hidePost: Promisify<typeof GrazeClient.Service.hidePost>;
-  unhidePost: Promisify<typeof GrazeClient.Service.unhidePost>;
-  updateAlgorithm: Promisify<typeof GrazeClient.Service.updateAlgorithm>;
-  publishAlgorithm: Promisify<typeof GrazeClient.Service.publishAlgorithm>;
+  getFeed: Promisify<GrazeClientService["getFeed"]>;
+  getFeeds: Promisify<GrazeClientService["getFeeds"]>;
+  hidePost: Promisify<GrazeClientService["hidePost"]>;
+  unhidePost: Promisify<GrazeClientService["unhidePost"]>;
+  updateAlgorithm: Promisify<GrazeClientService["updateAlgorithm"]>;
+  publishAlgorithm: Promisify<GrazeClientService["publishAlgorithm"]>;
   stickyposts: {
-    get: Promisify<typeof GrazeClient.Service.stickyposts.get>;
-    create: Promisify<typeof GrazeClient.Service.stickyposts.create>;
-    delete: Promisify<typeof GrazeClient.Service.stickyposts.delete>;
-    update: Promisify<typeof GrazeClient.Service.stickyposts.update>;
+    get: Promisify<GrazeClientService["stickyposts"]["get"]>;
+    create: Promisify<GrazeClientService["stickyposts"]["create"]>;
+    delete: Promisify<GrazeClientService["stickyposts"]["delete"]>;
+    update: Promisify<GrazeClientService["stickyposts"]["update"]>;
   };
 
   constructor({
@@ -35,11 +35,16 @@ export class GrazeService {
       ["GRAZE_COOKIE", cookie],
       ["GRAZE_USER_ID", userId.toString()],
     ]);
-    const provider = ConfigProvider.fromMap(envMap);
-    const layer = Layer.setConfigProvider(provider);
+    const provider = ConfigProvider.make((path) => {
+      const value = envMap.get(path.join("."));
+      return Effect.succeed(
+        value !== undefined ? ConfigProvider.makeValue(value) : undefined,
+      );
+    });
+    const layer = ConfigProvider.layer(provider);
     const make = setup.pipe(
-      Effect.provide(GrazeClient.Default),
-      Effect.provide(layer)
+      Effect.provide(GrazeClient.layer),
+      Effect.provide(layer),
     );
     const api = Effect.runSync(make);
     this.getFeed = api.getFeed;
@@ -99,5 +104,5 @@ const setup = Effect.gen(function* () {
   };
 });
 
+export { Algo, F } from "./builder.js";
 export * from "./schema/index.js";
-export { F, Algo } from "./builder.js";

package/src/schema/Post.ts

@@ -12,21 +12,21 @@ export const Author = S.Struct({
   labels: S.Array(S.Any),
   viewer: S.Any,
   createdAt: S.String,
-  associated: S.Union(S.Null, S.Any),
+  associated: S.Union([S.Null, S.Any]),
   displayName: S.String,
 });
 export type Author = typeof Author.Type;
 
 export const Record = S.Struct({
-  tags: S.Union(S.Null, S.Any),
+  tags: S.Union([S.Null, S.Any]),
   text: S.String,
   $type: S.String,
   embed: S.Any,
   langs: S.NullOr(S.Array(S.String)),
-  reply: S.Union(S.Null, S.Any),
+  reply: S.Union([S.Null, S.Any]),
   facets: S.NullOr(S.Array(S.Any)),
-  labels: S.Union(S.Null, S.Any),
-  entities: S.Union(S.Null, S.Any),
+  labels: S.Union([S.Null, S.Any]),
+  entities: S.Union([S.Null, S.Any]),
   createdAt: S.String,
 });
 export type Record = typeof Record.Type;
@@ -44,7 +44,7 @@ export const Post = S.Struct({
   likeCount: S.Number,
   quoteCount: S.Number,
   replyCount: S.Number,
-  threadgate: S.Union(S.Null, S.Unknown),
+  threadgate: S.Union([S.Null, S.Unknown]),
   repostCount: S.Number,
 });
 export type Post = typeof Post.Type;

package/src/schema/StickyPosts.ts

@@ -1,11 +1,7 @@
 import { Schema as S } from "effect";
 import { Post } from "./Post.js";
-import { HttpApiSchema } from "@effect/platform";
 
-export const StickyPostIdParam = HttpApiSchema.param(
-  "stickyPostId",
-  S.NumberFromString
-);
+export const StickyPostIdParam = S.NumberFromString;
 export type StickyPostIdParam = typeof StickyPostIdParam.Type;
 
 export const StoppingCriteria = S.Struct({
@@ -13,7 +9,7 @@ export const StoppingCriteria = S.Struct({
 });
 export type StoppingCriteria = typeof StoppingCriteria.Type;
 
-export const StickyType = S.Literal("pinned", "rotating");
+export const StickyType = S.Literals(["pinned", "rotating"]);
 export type StickyType = typeof StickyType.Type;
 
 const StickyPostBase = S.Struct({
@@ -41,7 +37,7 @@ export const GetStickyPostsBody = S.Struct({
       author: S.String,
       created_at: S.String,
       updated_at: S.String,
-    })
+    }),
   ),
 });
 export type GetStickyPostsBody = typeof GetStickyPostsBody.Type;