@clioplaylists/clio 0.1.5 → 0.1.7

package/dist/start.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/util/retry.d.ts

@@ -0,0 +1,2 @@
+export declare const RETRYABLE_HTTP_STATUS_CODES: Set<number>;
+export declare const retryXrpc: <T>(fn: () => Promise<T>, opts?: import("@atproto/common").RetryOptions) => Promise<T>;

package/dist/util/retry.js

@@ -0,0 +1,13 @@
+import { createRetryable } from '@atproto/common';
+import { ResponseType, XRPCError } from '@atproto/xrpc';
+export const RETRYABLE_HTTP_STATUS_CODES = new Set([
+    408, 425, 429, 500, 502, 503, 504, 522, 524,
+]);
+export const retryXrpc = createRetryable((err) => {
+    if (err instanceof XRPCError) {
+        if (err.status === ResponseType.Unknown)
+            return true;
+        return RETRYABLE_HTTP_STATUS_CODES.has(err.status);
+    }
+    return false;
+});

package/dist/util/uris.d.ts

@@ -0,0 +1 @@
+export declare function uriToDid(uri: string): string;

package/dist/util/uris.js

@@ -0,0 +1,4 @@
+import { AtUri } from '@atproto/syntax';
+export function uriToDid(uri) {
+    return new AtUri(uri).hostname;
+}

package/dist/util.d.ts

@@ -0,0 +1,23 @@
+import { CID } from 'multiformats/cid';
+import { Record } from './rpc/clio_pb';
+export type ParsedLabelers = {
+    dids: string[];
+    redact: Set<string>;
+};
+export type RecordInfo<T> = {
+    record: T;
+    cid: string;
+    sortedAt: Date;
+    indexedAt: Date;
+    takedownRef: string | undefined;
+};
+export declare const defaultLabelerHeader: (dids: string[]) => ParsedLabelers;
+export declare const formatLabelerHeader: (parsed: ParsedLabelers) => string;
+export declare const parseRecord: <T>(entry: Record, includeTakedowns: boolean) => RecordInfo<T> | undefined;
+export declare const parseRecordBytes: <T>(bytes: Uint8Array | undefined) => T | undefined;
+export declare const parseJsonBytes: (bytes: Uint8Array | undefined) => unknown;
+export declare const parseCid: (cidStr: string | undefined) => CID | undefined;
+export declare const safeTakedownRef: (obj?: {
+    takenDown: boolean;
+    takedownRef: string;
+}) => string | undefined;

package/dist/util.js

@@ -0,0 +1,76 @@
+import { jsonToLex } from '@atproto/lexicon';
+import { CID } from 'multiformats/cid';
+import * as ui8 from 'uint8arrays';
+import { lexicons } from './lexicons/lexicons';
+export const defaultLabelerHeader = (dids) => {
+    return {
+        dids,
+        redact: new Set(dids),
+    };
+};
+export const formatLabelerHeader = (parsed) => {
+    const parts = parsed.dids.map((did) => parsed.redact.has(did) ? `${did};redact` : did);
+    return parts.join(',');
+};
+export const parseRecord = (entry, includeTakedowns) => {
+    if (!includeTakedowns && entry.takenDown) {
+        return undefined;
+    }
+    const record = parseRecordBytes(entry.record);
+    const cid = entry.cid;
+    const sortedAt = entry.sortedAt?.toDate() ?? new Date(0);
+    const indexedAt = entry.indexedAt?.toDate() ?? new Date(0);
+    if (!record || !cid)
+        return;
+    if (!isValidRecord(record)) {
+        return;
+    }
+    return {
+        record,
+        cid,
+        sortedAt,
+        indexedAt,
+        takedownRef: safeTakedownRef(entry),
+    };
+};
+const isValidRecord = (json) => {
+    const lexRecord = jsonToLex(json);
+    if (typeof lexRecord?.['$type'] !== 'string') {
+        return false;
+    }
+    try {
+        lexicons.assertValidRecord(lexRecord['$type'], lexRecord);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+// @NOTE not parsed into lex format, so will not match lexicon record types on CID and blob values.
+export const parseRecordBytes = (bytes) => {
+    return parseJsonBytes(bytes);
+};
+export const parseJsonBytes = (bytes) => {
+    if (!bytes || bytes.byteLength === 0)
+        return;
+    const parsed = JSON.parse(ui8.toString(bytes, 'utf8'));
+    return parsed ?? undefined;
+};
+export const parseCid = (cidStr) => {
+    if (!cidStr || cidStr.length === 0)
+        return;
+    try {
+        return CID.parse(cidStr);
+    }
+    catch {
+        return;
+    }
+};
+export const safeTakedownRef = (obj) => {
+    if (!obj)
+        return;
+    if (obj.takedownRef)
+        return obj.takedownRef;
+    if (obj.takenDown)
+        return 'BSKY-TAKEDOWN-UNKNOWN';
+};

package/package.json

@@ -1,18 +1,19 @@
 {
   "name": "@clioplaylists/clio",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Appview server for the Clio application",
-  "main": "start.js",
-  "types": "index.d.ts",
+  "main": "dist/start.js",
+  "types": "dist/index.d.ts",
+  "files": [ "dist" ],
   "scripts": {
-    "build": "tsc --project ./tsconfig.json && cp ./{.env,package.json,.npmignore} ./dist",
+    "build": "tsc --project ./tsconfig.json && cp .env ./dist",
     "start": "node dist/start.js",
     "dev": "nodemon -r tsconfig-paths/register src/index.ts",
     "test": "echo \"Error: no test specified\" && exit 1",
     "lex:gen": "lex gen-server --yes ./src/lexicons ../../lexicons/com/clioplaylists/alpha/*/* ../../lexicons/com/atproto/*/*",
     "buf:gen": "buf generate ./src/rpc",
-    "pretty": "prettier --write .",
-    "pretty:check": "prettier --check ."
+    "pretty": "prettier --write ./src",
+    "pretty:check": "prettier --check ./src"
   },
   "repository": {
     "type": "git",
@@ -27,7 +28,6 @@
     "url": "https://github.com/Hoid/clio/issues"
   },
   "homepage": "https://github.com/Hoid/clio#readme",
-  "files": [ "./dist" ],
   "dependencies": {
     "@atproto/api": "^0.13.35",
     "@atproto/common": "^0.4.4",