@clioplaylists/clio 0.1.4 → 0.1.6

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,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryXrpc = exports.RETRYABLE_HTTP_STATUS_CODES = void 0;
+const common_1 = require("@atproto/common");
+const xrpc_1 = require("@atproto/xrpc");
+exports.RETRYABLE_HTTP_STATUS_CODES = new Set([
+    408, 425, 429, 500, 502, 503, 504, 522, 524,
+]);
+exports.retryXrpc = (0, common_1.createRetryable)((err) => {
+    if (err instanceof xrpc_1.XRPCError) {
+        if (err.status === xrpc_1.ResponseType.Unknown)
+            return true;
+        return exports.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,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uriToDid = uriToDid;
+const syntax_1 = require("@atproto/syntax");
+function uriToDid(uri) {
+    return new syntax_1.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,119 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeTakedownRef = exports.parseCid = exports.parseJsonBytes = exports.parseRecordBytes = exports.parseRecord = exports.formatLabelerHeader = exports.defaultLabelerHeader = void 0;
+const lexicon_1 = require("@atproto/lexicon");
+const cid_1 = require("multiformats/cid");
+const ui8 = __importStar(require("uint8arrays"));
+const lexicons_1 = require("./lexicons/lexicons");
+const defaultLabelerHeader = (dids) => {
+    return {
+        dids,
+        redact: new Set(dids),
+    };
+};
+exports.defaultLabelerHeader = defaultLabelerHeader;
+const formatLabelerHeader = (parsed) => {
+    const parts = parsed.dids.map((did) => parsed.redact.has(did) ? `${did};redact` : did);
+    return parts.join(',');
+};
+exports.formatLabelerHeader = formatLabelerHeader;
+const parseRecord = (entry, includeTakedowns) => {
+    if (!includeTakedowns && entry.takenDown) {
+        return undefined;
+    }
+    const record = (0, exports.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: (0, exports.safeTakedownRef)(entry),
+    };
+};
+exports.parseRecord = parseRecord;
+const isValidRecord = (json) => {
+    const lexRecord = (0, lexicon_1.jsonToLex)(json);
+    if (typeof lexRecord?.['$type'] !== 'string') {
+        return false;
+    }
+    try {
+        lexicons_1.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.
+const parseRecordBytes = (bytes) => {
+    return (0, exports.parseJsonBytes)(bytes);
+};
+exports.parseRecordBytes = parseRecordBytes;
+const parseJsonBytes = (bytes) => {
+    if (!bytes || bytes.byteLength === 0)
+        return;
+    const parsed = JSON.parse(ui8.toString(bytes, 'utf8'));
+    return parsed ?? undefined;
+};
+exports.parseJsonBytes = parseJsonBytes;
+const parseCid = (cidStr) => {
+    if (!cidStr || cidStr.length === 0)
+        return;
+    try {
+        return cid_1.CID.parse(cidStr);
+    }
+    catch {
+        return;
+    }
+};
+exports.parseCid = parseCid;
+const safeTakedownRef = (obj) => {
+    if (!obj)
+        return;
+    if (obj.takedownRef)
+        return obj.takedownRef;
+    if (obj.takenDown)
+        return 'BSKY-TAKEDOWN-UNKNOWN';
+};
+exports.safeTakedownRef = safeTakedownRef;

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@clioplaylists/clio",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Appview server for the Clio application",
-  "main": "start.js",
-  "types": "index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
-    "build": "tsc --project ./tsconfig.json && cp ./{.env,package.json} ./dist",
+    "build": "tsc --project ./tsconfig.json && cp ./{.env,.npmignore} ./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 +27,7 @@
     "url": "https://github.com/Hoid/clio/issues"
   },
   "homepage": "https://github.com/Hoid/clio#readme",
-  "files": [ "./dist" ],
+  "files": [ "dist" ],
   "dependencies": {
     "@atproto/api": "^0.13.35",
     "@atproto/common": "^0.4.4",