graze-client 0.8.0 → 0.8.1

package/src/GrazeClient.ts

@@ -1,10 +1,3 @@
-import {
-  AlgoUpdateResponse,
-  GetAlgoResponse,
-  GetAlgorithmsResponse,
-  HidePostBody,
-  UnhidePostBody,
-} from "./schema/shared.js";
 import {
   FetchHttpClient,
   HttpApi,
@@ -13,32 +6,39 @@ import {
   HttpApiGroup,
   HttpApiSchema,
   HttpClient,
-  HttpClientRequest,
-} from "@effect/platform";
-import { Config, Data, Effect, Redacted, Schema } from "effect";
+  HttpClientRequest
+} from "@effect/platform"
+import { Config, Data, Effect, Redacted, Schema } from "effect"
+import {
+  AlgoUpdateResponse,
+  GetAlgoResponse,
+  GetAlgorithmsResponse,
+  HidePostBody,
+  UnhidePostBody
+} from "./schema/shared.js"
 
-import * as Form from "./schema/UpdateAlgorithmPayload.js";
-import { FeedIdParam, UserIdParam } from "./common.js";
-import { StickyPostsApiGroup } from "./stickyposts.js";
+import { FeedIdParam, UserIdParam } from "./common.js"
+import * as Form from "./schema/UpdateAlgorithmPayload.js"
+import { StickyPostsApiGroup } from "./stickyposts.js"
 
 function isStringOrBlob(val: unknown): val is string | Blob {
-  return typeof val === "string" || val instanceof Blob;
+  return typeof val === "string" || val instanceof Blob
 }
 
 const encodeForm = (obj: Form.FullForm) =>
-  Effect.gen(function* () {
-    const encoded = yield* Schema.encode(Form.FullForm)(obj);
-    const formData = new FormData();
+  Effect.gen(function*() {
+    const encoded = yield* Schema.encode(Form.FullForm)(obj)
+    const formData = new FormData()
     for (const key in encoded) {
-      if (encoded.hasOwnProperty(key)) {
-        const val = encoded[key as keyof Form.FullForm];
+      if (Object.prototype.hasOwnProperty.call(encoded, key)) {
+        const val = encoded[key as keyof Form.FullForm]
         if (isStringOrBlob(val)) {
-          formData.append(key, val);
+          formData.append(key, val)
         }
       }
     }
-    return formData;
-  });
+    return formData
+  })
 
 const GrazeApiGroup = HttpApiGroup.make("graze", { topLevel: true })
   .add(
@@ -46,7 +46,7 @@ const GrazeApiGroup = HttpApiGroup.make("graze", { topLevel: true })
       .addSuccess(GetAlgorithmsResponse)
       .setPayload(
         Schema.Struct({
-          user_id: UserIdParam,
+          user_id: UserIdParam
         })
       )
   )
@@ -74,16 +74,17 @@ const GrazeApiGroup = HttpApiGroup.make("graze", { topLevel: true })
     HttpApiEndpoint.post("unhidePost")`/app/unhide_post`
       .setPayload(UnhidePostBody)
       .addSuccess(Schema.Unknown)
-  );
+  )
 
 class GrazeApiDef extends HttpApi.make("grazeApi")
   .add(GrazeApiGroup)
   .add(StickyPostsApiGroup)
-  .addError(Schema.Unknown) {}
+  .addError(Schema.Unknown)
+{}
 
-const grazeLive = Effect.gen(function* () {
-  const baseUrl = yield* Config.url("GRAZE_API_URL");
-  const cookie = yield* Config.redacted("GRAZE_COOKIE");
+const grazeLive = Effect.gen(function*() {
+  const baseUrl = yield* Config.url("GRAZE_API_URL")
+  const cookie = yield* Config.redacted("GRAZE_COOKIE")
 
   const client = yield* HttpApiClient.make(GrazeApiDef, {
     baseUrl: baseUrl.toString(),
@@ -92,38 +93,38 @@ const grazeLive = Effect.gen(function* () {
         HttpClient.filterStatusOk,
         HttpClient.mapRequest(
           HttpClientRequest.setHeaders({
-            cookie: Redacted.value(cookie),
+            cookie: Redacted.value(cookie)
           })
         )
-      ),
-  });
+      )
+  })
 
   const updateAlgorithm = (data: Form.FullForm) =>
-    Effect.gen(function* () {
-      const formData = yield* encodeForm(data);
-      return yield* client.updateAlgorithm({ payload: formData });
-    });
+    Effect.gen(function*() {
+      const formData = yield* encodeForm(data)
+      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.integer("GRAZE_USER_ID")
+  const getFeeds = () => client.getFeeds({ payload: { user_id: userId } })
 
   return {
     ...client,
     updateAlgorithm,
-    getFeeds,
-  };
-});
+    getFeeds
+  }
+})
 
 export class GrazeClient extends Effect.Service<GrazeClient>()("GrazeClient", {
   effect: grazeLive,
-  dependencies: [FetchHttpClient.layer],
+  dependencies: [FetchHttpClient.layer]
 }) {
   // TODO: test service
 }
 
 export class GrazeError extends Data.TaggedError("GrazeError")<{
-  message: string;
-  status: number;
-  statusText: string;
-  json: unknown;
+  message: string
+  status: number
+  statusText: string
+  json: unknown
 }> {}

package/src/builder.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   AttributeComparison,
   AttributeName,
   AttributeValue,
@@ -11,148 +11,144 @@ import {
   RegexNegationMatches,
   SocialGraph,
   TextMatchesAny,
-  TextMatchesNone,
-} from "./schema/index.js";
+  TextMatchesNone
+} from "./schema/index.js"
 
 const neverMatch: Filter = {
-  or: [],
-};
+  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.
-      flatFilters.push(neverMatch);
+      flatFilters.push(neverMatch)
     } else if ("and" in f) {
       // Automatically flatten nested ands.
-      flatFilters.push(...f.and);
+      flatFilters.push(...f.and)
     } else {
-      flatFilters.push(f);
+      flatFilters.push(f)
     }
-  });
-  return { and: flatFilters };
-};
-const or = (...filters: (Filter | null)[]): Filter => {
-  const flatFilters: Filter[] = [];
+  })
+  return { and: flatFilters }
+}
+const or = (...filters: Array<Filter | null>): Filter => {
+  const flatFilters: Array<Filter> = []
   filters
     .filter((f) => f !== null)
     .forEach((f) => {
       if ("or" in f) {
-        flatFilters.push(...f.or);
+        flatFilters.push(...f.or)
       } else {
-        flatFilters.push(f);
+        flatFilters.push(f)
       }
-    });
-  return { or: flatFilters };
-};
+    })
+  return { or: flatFilters }
+}
 
 const regexMatches = (
   attribute: RegexMatches["regex_matches"][0],
   regex: string
 ): RegexMatches => ({
-  regex_matches: [attribute, regex, true],
-});
+  regex_matches: [attribute, regex, true]
+})
 
 const regexNegationMatches = (
   attribute: RegexNegationMatches["regex_negation_matches"][0],
   regex: string
 ): RegexNegationMatches => ({
-  regex_negation_matches: [attribute, regex, true],
-});
+  regex_negation_matches: [attribute, regex, true]
+})
 
 const textMatchesAny = ({
   attribute,
-  patterns,
   caseInsensitive = true,
-  useRegex = false,
+  patterns,
+  useRegex = false
 }: {
-  attribute: AttributeName;
-  patterns: string[];
-  caseInsensitive?: boolean;
-  useRegex?: boolean;
+  attribute: AttributeName
+  patterns: Array<string>
+  caseInsensitive?: boolean
+  useRegex?: boolean
 }): TextMatchesAny => ({
-  regex_any: [attribute, patterns, caseInsensitive, useRegex],
-});
+  regex_any: [attribute, patterns, caseInsensitive, useRegex]
+})
 
 const textMatchesNone = ({
   attribute,
-  patterns,
   caseInsensitive = true,
-  useRegex = false,
+  patterns,
+  useRegex = false
 }: {
-  attribute: AttributeName;
-  patterns: string[];
-  caseInsensitive?: boolean;
-  useRegex?: boolean;
+  attribute: AttributeName
+  patterns: Array<string>
+  caseInsensitive?: boolean
+  useRegex?: boolean
 }): TextMatchesNone => ({
-  regex_none: [attribute, patterns, caseInsensitive, useRegex],
-});
+  regex_none: [attribute, patterns, caseInsensitive, useRegex]
+})
 
 const isListMember = (uri: string): ListMemberFilter => ({
-  list_member: [uri, "in"],
-});
+  list_member: [uri, "in"]
+})
 const isNotListMember = (uri: string): ListMemberFilter => ({
-  list_member: [uri, "not_in"],
-});
+  list_member: [uri, "not_in"]
+})
 const socialGraph = (
   identifier: string,
   op: SocialGraph["social_graph"][1],
   relation: SocialGraph["social_graph"][2]
 ): SocialGraph => ({
-  social_graph: [identifier, op, relation],
-});
-const posterIsFollowedBy = (identifier: string) =>
-  socialGraph(identifier, "in", "followers");
-const posterFollows = (identifier: string) =>
-  socialGraph(identifier, "in", "follows");
-const posterIsNotFollowedBy = (identifier: string) =>
-  socialGraph(identifier, "not_in", "followers");
-const posterDoesNotFollow = (identifier: string) =>
-  socialGraph(identifier, "not_in", "follows");
+  social_graph: [identifier, op, relation]
+})
+const posterIsFollowedBy = (identifier: string) => socialGraph(identifier, "in", "followers")
+const posterFollows = (identifier: string) => socialGraph(identifier, "in", "follows")
+const posterIsNotFollowedBy = (identifier: string) => socialGraph(identifier, "not_in", "followers")
+const posterDoesNotFollow = (identifier: string) => socialGraph(identifier, "not_in", "follows")
 
 const embedContains = (type: EmbedType["embed_type"][1]): Filter => ({
-  embed_type: ["==", type],
-});
+  embed_type: ["==", type]
+})
 const embedDoesNotContain = (type: EmbedType["embed_type"][1]): Filter => ({
-  embed_type: ["!=", type],
-});
+  embed_type: ["!=", type]
+})
 
 const postTypeIs = (...types: PostTypeFilter["post_type"][1]): Filter => ({
-  post_type: ["in", types],
-});
+  post_type: ["in", types]
+})
 const postTypeIsNot = (...types: PostTypeFilter["post_type"][1]): Filter => ({
-  post_type: ["not_in", types],
-});
+  post_type: ["not_in", types]
+})
 
-const hasVideo: Filter = embedContains("video");
+const hasVideo: Filter = embedContains("video")
 
 const hasNoNSFWLabels: Filter = {
-  entity_excludes: ["labels", ["porn", "sexual", "nudity"]],
-};
+  entity_excludes: ["labels", ["porn", "sexual", "nudity"]]
+}
 const attributeCompare = (
   attr: AttributeName,
   op: AttributeComparison,
   value: AttributeValue
 ): Filter => ({
-  attribute_compare: [attr, op, value],
-});
+  attribute_compare: [attr, op, value]
+})
 
-const isPost: Filter = postTypeIsNot("reply", "quote");
-const isReply: Filter = postTypeIs("reply");
-const isQuote: Filter = postTypeIs("quote");
-const isNotReply: Filter = postTypeIsNot("reply");
-const isNotQuote: Filter = postTypeIsNot("quote");
+const isPost: Filter = postTypeIsNot("reply", "quote")
+const isReply: Filter = postTypeIs("reply")
+const isQuote: Filter = postTypeIs("quote")
+const isNotReply: Filter = postTypeIsNot("reply")
+const isNotQuote: Filter = postTypeIsNot("quote")
 
 const isContentOk = (threshold: number = 0.9): ContentModerationBlock => ({
-  content_moderation: ["OK", ">=", threshold],
-});
+  content_moderation: ["OK", ">=", threshold]
+})
 
 export const Algo = {
-  filter: (...filters: Filter[]): { filter: Filter } => ({
-    filter: and(...filters),
-  }),
-};
+  filter: (...filters: Array<Filter>): { filter: Filter } => ({
+    filter: and(...filters)
+  })
+}
 
 export const F = {
   and,
@@ -180,5 +176,5 @@ export const F = {
   isNotQuote,
   isContentOk,
   embedContains,
-  embedDoesNotContain,
-};
+  embedDoesNotContain
+}

package/src/common.ts

@@ -1,11 +1,11 @@
-import { HttpApiSchema } from "@effect/platform";
-import { Schema } from "effect";
+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
-);
+)

package/src/index.ts

@@ -1,89 +1,85 @@
-import { ConfigProvider, Effect, Layer } from "effect";
-import { GrazeClient } from "./GrazeClient.js";
+import { ConfigProvider, Effect, Layer } from "effect"
+import { GrazeClient } from "./GrazeClient.js"
 
 type Promisify<T> = T extends (
-  ...args: any[]
-) => Effect.Effect<infer A, infer E, never>
-  ? (...args: Parameters<T>) => Promise<A>
-  : 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<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>
   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<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>
+  }
 
   constructor({
     apiUrl,
     cookie,
-    userId,
+    userId
   }: {
-    apiUrl: string;
-    cookie: string;
-    userId: number;
+    apiUrl: string
+    cookie: string
+    userId: number
   }) {
     const envMap = new Map([
       ["GRAZE_API_URL", apiUrl],
       ["GRAZE_COOKIE", cookie],
-      ["GRAZE_USER_ID", userId.toString()],
-    ]);
-    const provider = ConfigProvider.fromMap(envMap);
-    const layer = Layer.setConfigProvider(provider);
+      ["GRAZE_USER_ID", userId.toString()]
+    ])
+    const provider = ConfigProvider.fromMap(envMap)
+    const layer = Layer.setConfigProvider(provider)
     const make = setup.pipe(
       Effect.provide(GrazeClient.Default),
       Effect.provide(layer)
-    );
-    const api = Effect.runSync(make);
-    this.getFeed = api.getFeed;
-    this.getFeeds = api.getFeeds;
-    this.hidePost = api.hidePost;
-    this.unhidePost = api.unhidePost;
-    this.updateAlgorithm = api.updateAlgorithm;
-    this.publishAlgorithm = api.publishAlgorithm;
+    )
+    const api = Effect.runSync(make)
+    this.getFeed = api.getFeed
+    this.getFeeds = api.getFeeds
+    this.hidePost = api.hidePost
+    this.unhidePost = api.unhidePost
+    this.updateAlgorithm = api.updateAlgorithm
+    this.publishAlgorithm = api.publishAlgorithm
     this.stickyposts = {
       get: api.getStickyPosts,
       create: api.createStickyPost,
       delete: api.deleteStickyPost,
-      update: api.updateStickyPost,
-    };
+      update: api.updateStickyPost
+    }
   }
 }
 
-const setup = Effect.gen(function* () {
-  const client = yield* GrazeClient;
-  const getFeed = (...args: Parameters<typeof client.getFeed>) =>
-    client.getFeed(...args).pipe(Effect.runPromise);
-  const getFeeds = (...args: Parameters<typeof client.getFeeds>) =>
-    client.getFeeds(...args).pipe(Effect.runPromise);
-  const hidePost = (...args: Parameters<typeof client.hidePost>) =>
-    client.hidePost(...args).pipe(Effect.runPromise);
+const setup = Effect.gen(function*() {
+  const client = yield* GrazeClient
+  const getFeed = (...args: Parameters<typeof client.getFeed>) => client.getFeed(...args).pipe(Effect.runPromise)
+  const getFeeds = (...args: Parameters<typeof client.getFeeds>) => client.getFeeds(...args).pipe(Effect.runPromise)
+  const hidePost = (...args: Parameters<typeof client.hidePost>) => client.hidePost(...args).pipe(Effect.runPromise)
   const unhidePost = (...args: Parameters<typeof client.unhidePost>) =>
-    client.unhidePost(...args).pipe(Effect.runPromise);
+    client.unhidePost(...args).pipe(Effect.runPromise)
   const updateAlgorithm = (
     ...args: Parameters<typeof client.updateAlgorithm>
-  ) => client.updateAlgorithm(...args).pipe(Effect.runPromise);
+  ) => client.updateAlgorithm(...args).pipe(Effect.runPromise)
   const publishAlgorithm = (
     ...args: Parameters<typeof client.publishAlgorithm>
-  ) => client.publishAlgorithm(...args).pipe(Effect.runPromise);
+  ) => client.publishAlgorithm(...args).pipe(Effect.runPromise)
   const getStickyPosts = (...args: Parameters<typeof client.stickyposts.get>) =>
-    client.stickyposts.get(...args).pipe(Effect.runPromise);
+    client.stickyposts.get(...args).pipe(Effect.runPromise)
   const createStickyPost = (
     ...args: Parameters<typeof client.stickyposts.create>
-  ) => client.stickyposts.create(...args).pipe(Effect.runPromise);
+  ) => client.stickyposts.create(...args).pipe(Effect.runPromise)
   const deleteStickyPost = (
     ...args: Parameters<typeof client.stickyposts.delete>
-  ) => client.stickyposts.delete(...args).pipe(Effect.runPromise);
+  ) => client.stickyposts.delete(...args).pipe(Effect.runPromise)
   const updateStickyPost = (
     ...args: Parameters<typeof client.stickyposts.update>
-  ) => client.stickyposts.update(...args).pipe(Effect.runPromise);
+  ) => client.stickyposts.update(...args).pipe(Effect.runPromise)
 
   return {
     getFeed,
@@ -95,9 +91,9 @@ const setup = Effect.gen(function* () {
     getStickyPosts,
     createStickyPost,
     deleteStickyPost,
-    updateStickyPost,
-  };
-});
+    updateStickyPost
+  }
+})
 
-export * from "./schema/index.js";
-export { F, Algo } from "./builder.js";
+export { Algo, F } from "./builder.js"
+export * from "./schema/index.js"

package/src/schema/Post.ts

@@ -1,4 +1,4 @@
-import { Schema as S } from "effect";
+import { Schema as S } from "effect"
 
 /**
  * Schema for Bluesky objects
@@ -13,9 +13,9 @@ export const Author = S.Struct({
   viewer: S.Any,
   createdAt: S.String,
   associated: S.Union(S.Null, S.Any),
-  displayName: S.String,
-});
-export type Author = typeof Author.Type;
+  displayName: S.String
+})
+export type Author = typeof Author.Type
 
 export const Record = S.Struct({
   tags: S.Union(S.Null, S.Any),
@@ -27,9 +27,9 @@ export const Record = S.Struct({
   facets: S.NullOr(S.Array(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;
+  createdAt: S.String
+})
+export type Record = typeof Record.Type
 
 export const Post = S.Struct({
   cid: S.String,
@@ -45,6 +45,6 @@ export const Post = S.Struct({
   quoteCount: S.Number,
   replyCount: S.Number,
   threadgate: S.Union(S.Null, S.Unknown),
-  repostCount: S.Number,
-});
-export type Post = typeof Post.Type;
+  repostCount: S.Number
+})
+export type Post = typeof Post.Type

package/src/schema/StickyPosts.ts

@@ -1,33 +1,33 @@
-import { Schema as S } from "effect";
-import { Post } from "./Post.js";
-import { HttpApiSchema } from "@effect/platform";
+import { HttpApiSchema } from "@effect/platform"
+import { Schema as S } from "effect"
+import { Post } from "./Post.js"
 
 export const StickyPostIdParam = HttpApiSchema.param(
   "stickyPostId",
   S.NumberFromString
-);
-export type StickyPostIdParam = typeof StickyPostIdParam.Type;
+)
+export type StickyPostIdParam = typeof StickyPostIdParam.Type
 
 export const StoppingCriteria = S.Struct({
-  expiration_time: S.Number.pipe(S.optional),
-});
-export type StoppingCriteria = typeof StoppingCriteria.Type;
+  expiration_time: S.Number.pipe(S.optional)
+})
+export type StoppingCriteria = typeof StoppingCriteria.Type
 
-export const StickyType = S.Literal("pinned", "rotating");
-export type StickyType = typeof StickyType.Type;
+export const StickyType = S.Literal("pinned", "rotating")
+export type StickyType = typeof StickyType.Type
 
 const StickyPostBase = S.Struct({
   is_active: S.Boolean,
-  sticky_type: StickyType,
-});
+  sticky_type: StickyType
+})
 
 export const CreateStickyPostBody = S.Struct({
   algo_id: S.Number,
   post_url: S.String,
   stopping_criteria: StoppingCriteria.pipe(S.optional),
-  ...StickyPostBase.fields,
-});
-export type CreateStickyPostBody = typeof CreateStickyPostBody.Type;
+  ...StickyPostBase.fields
+})
+export type CreateStickyPostBody = typeof CreateStickyPostBody.Type
 
 export const GetStickyPostsBody = S.Struct({
   sticky_posts: S.Array(
@@ -40,13 +40,13 @@ export const GetStickyPostsBody = S.Struct({
       post: Post,
       author: S.String,
       created_at: S.String,
-      updated_at: S.String,
+      updated_at: S.String
     })
-  ),
-});
-export type GetStickyPostsBody = typeof GetStickyPostsBody.Type;
+  )
+})
+export type GetStickyPostsBody = typeof GetStickyPostsBody.Type
 
 export const StickyPostSuccess = S.Struct({
-  message: S.String,
-});
-export type StickyPostSuccess = typeof StickyPostSuccess.Type;
+  message: S.String
+})
+export type StickyPostSuccess = typeof StickyPostSuccess.Type