@clioplaylists/clio 0.1.4 → 0.1.6

package/dist/api/com/clioplaylists/alpha/actor/getProfile.js

@@ -0,0 +1,37 @@
+"use strict";
+// import AppContext from '../../../../../context'
+// import { Server } from '../../../../../lexicons'
+// import { OutputSchema } from '../../../../../lexicons/types/com/clioplaylists/alpha/feed/getSongs'
+// import { Record as SongRecord } from '../../../../../lexicons/types/com/clioplaylists/alpha/feed/song'
+// import { parseRecord } from '../../../../../util'
+// import { resHeaders } from '../../../../util'
+// export default function (server: Server, ctx: AppContext) {
+//   server.com.clioplaylists.alpha.feed.getSongs({
+//     handler: async ({ params, auth, req }) => {
+//       const res = await ctx.dataplane.getSongRecords({})
+//       let results: OutputSchema = {
+//         songs: []
+//       }
+//       res.records.forEach((recordWrapper) => {
+//         const recordRes = parseRecord<SongRecord>(recordWrapper, false)
+//         if (!recordRes) {
+//           console.log("Could not deserialize SongRecord")
+//           return
+//         }
+//         results.songs.push({
+//           trackName: recordRes.record.trackName,
+//           trackMbId: recordRes.record.trackMbId,
+//           artistNames: recordRes.record.artistNames,
+//           artistMbIds: recordRes.record.artistMbIds,
+//           albumArtwork: recordRes.record.albumArtwork,
+//           createdAt: recordRes.record.createdAt
+//         })
+//       })
+//       return {
+//         encoding: 'application/json',
+//         body: results,
+//         headers: resHeaders({}),
+//       }
+//     }
+//   })
+// }

package/dist/api/com/clioplaylists/alpha/feed/getSongs.js

@@ -0,0 +1,37 @@
+"use strict";
+// import AppContext from '../../../../../context'
+// import { Server } from '../../../../../lexicons'
+// import { OutputSchema } from '../../../../../lexicons/types/com/clioplaylists/alpha/feed/getSongs'
+// import { Record as SongRecord } from '../../../../../lexicons/types/com/clioplaylists/alpha/feed/song'
+// import { parseRecord } from '../../../../../util'
+// import { resHeaders } from '../../../../util'
+// export default function (server: Server, ctx: AppContext) {
+//   server.com.clioplaylists.alpha.feed.getSongs({
+//     handler: async ({ params, auth, req }) => {
+//       const res = await ctx.dataplane.getSongRecords({})
+//       let results: OutputSchema = {
+//         songs: []
+//       }
+//       res.records.forEach((recordWrapper) => {
+//         const recordRes = parseRecord<SongRecord>(recordWrapper, false)
+//         if (!recordRes) {
+//           console.log("Could not deserialize SongRecord")
+//           return
+//         }
+//         results.songs.push({
+//           trackName: recordRes.record.trackName,
+//           trackMbId: recordRes.record.trackMbId,
+//           artistNames: recordRes.record.artistNames,
+//           artistMbIds: recordRes.record.artistMbIds,
+//           albumArtwork: recordRes.record.albumArtwork,
+//           createdAt: recordRes.record.createdAt
+//         })
+//       })
+//       return {
+//         encoding: 'application/json',
+//         body: results,
+//         headers: resHeaders({}),
+//       }
+//     }
+//   })
+// }

package/dist/api/health.d.ts

@@ -0,0 +1,3 @@
+import express from 'express';
+import AppContext from '../context';
+export declare const createRouter: (ctx: AppContext) => express.Router;

package/dist/api/health.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRouter = void 0;
+const express_1 = __importDefault(require("express"));
+const createRouter = (ctx) => {
+    const router = express_1.default.Router();
+    router.get('/', function (req, res) {
+        res.type('text/plain');
+        res.send(`
+  ___  __    ____  _____ 
+ / __)(  )  (_  _)(  _  )
+( (__  )(__  _)(_  )(_)( 
+ \___)(____)(____)(_____)
+
+This is an AT Protocol Application View (AppView) for the "clioplaylists.com" application.
+
+Most API routes are under /xrpc/
+
+      Code: https://github.com/Hoid/clio-api
+  Protocol: https://atproto.com
+`);
+    });
+    router.get('/xrpc/_health', async function (req, res) {
+        const { version } = ctx.cfg;
+        res.send({ version });
+    });
+    return router;
+};
+exports.createRouter = createRouter;

package/dist/api/index.d.ts

@@ -0,0 +1,4 @@
+import AppContext from '../context';
+import { Server } from '../lexicons';
+export * as health from './health';
+export default function (server: Server, ctx: AppContext): Server;

package/dist/api/index.js

@@ -0,0 +1,43 @@
+"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.health = void 0;
+exports.default = default_1;
+// import getSongs from './com/clioplaylists/alpha/feed/getSongs'
+exports.health = __importStar(require("./health"));
+function default_1(server, ctx) {
+    // getSongs(server, ctx)
+    return server;
+}

package/dist/api/util.d.ts

@@ -0,0 +1,9 @@
+import { ParsedLabelers } from '../util';
+export declare const ATPROTO_CONTENT_LABELERS = "Atproto-Content-Labelers";
+export declare const ATPROTO_REPO_REV = "Atproto-Repo-Rev";
+type ResHeaderOpts = {
+    labelers: ParsedLabelers;
+    repoRev: string | null;
+};
+export declare const resHeaders: (opts: Partial<ResHeaderOpts>) => Record<string, string>;
+export {};

package/dist/api/util.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resHeaders = exports.ATPROTO_REPO_REV = exports.ATPROTO_CONTENT_LABELERS = void 0;
+const util_1 = require("../util");
+exports.ATPROTO_CONTENT_LABELERS = 'Atproto-Content-Labelers';
+exports.ATPROTO_REPO_REV = 'Atproto-Repo-Rev';
+const resHeaders = (opts) => {
+    const headers = {};
+    if (opts.labelers) {
+        headers[exports.ATPROTO_CONTENT_LABELERS] = (0, util_1.formatLabelerHeader)(opts.labelers);
+    }
+    if (opts.repoRev) {
+        headers[exports.ATPROTO_REPO_REV] = opts.repoRev;
+    }
+    return headers;
+};
+exports.resHeaders = resHeaders;

package/dist/auth-verifier.d.ts

@@ -0,0 +1,92 @@
+import { VerifySignatureWithKeyFn } from '@atproto/xrpc-server';
+import express from 'express';
+import { KeyObject } from 'node:crypto';
+import { DataPlaneClient } from './client';
+type ReqCtx = {
+    req: express.Request;
+};
+type StandardAuthOpts = {
+    skipAudCheck?: boolean;
+    lxmCheck?: (method?: string) => boolean;
+};
+export declare enum RoleStatus {
+    Valid = 0,
+    Invalid = 1,
+    Missing = 2
+}
+type NullOutput = {
+    credentials: {
+        type: 'none';
+        iss: null;
+    };
+};
+type StandardOutput = {
+    credentials: {
+        type: 'standard';
+        aud: string;
+        iss: string;
+    };
+};
+type RoleOutput = {
+    credentials: {
+        type: 'role';
+        admin: boolean;
+    };
+};
+type ModServiceOutput = {
+    credentials: {
+        type: 'mod_service';
+        aud: string;
+        iss: string;
+    };
+};
+export type AuthVerifierOpts = {
+    ownDid: string;
+    alternateAudienceDids: string[];
+    modServiceDid: string;
+    adminPasses: string[];
+    entrywayJwtPublicKey?: KeyObject;
+};
+export declare class AuthVerifier {
+    dataplane: DataPlaneClient;
+    ownDid: string;
+    standardAudienceDids: Set<string>;
+    modServiceDid: string;
+    private adminPasses;
+    private entrywayJwtPublicKey?;
+    constructor(dataplane: DataPlaneClient, opts: AuthVerifierOpts);
+    standardOptionalParameterized: (opts: StandardAuthOpts) => (ctx: ReqCtx) => Promise<StandardOutput | NullOutput>;
+    standardOptional: (ctx: ReqCtx) => Promise<StandardOutput | NullOutput>;
+    standard: (ctx: ReqCtx) => Promise<StandardOutput>;
+    role: (ctx: ReqCtx) => RoleOutput;
+    standardOrRole: (ctx: ReqCtx) => Promise<StandardOutput | RoleOutput>;
+    optionalStandardOrRole: (ctx: ReqCtx) => Promise<StandardOutput | RoleOutput | NullOutput>;
+    entrywaySession: (reqCtx: ReqCtx) => Promise<StandardOutput>;
+    parseRoleCreds(req: express.Request): {
+        status: RoleStatus;
+        admin: boolean;
+        moderator: boolean;
+        triage: boolean;
+    } | {
+        status: RoleStatus;
+        admin: boolean;
+        moderator?: undefined;
+        triage?: undefined;
+    };
+    isModService(iss: string): boolean;
+    nullCreds(): NullOutput;
+    parseCreds(creds: StandardOutput | RoleOutput | ModServiceOutput | NullOutput): {
+        viewer: string | null;
+        includeTakedowns: boolean;
+        include3pBlocks: boolean;
+        canPerformTakedown: boolean;
+    };
+}
+export declare const parseBasicAuth: (token: string) => {
+    username: string;
+    password: string;
+} | null;
+export declare const buildBasicAuth: (username: string, password: string) => string;
+export declare const createPublicKeyObject: (publicKeyHex: string) => KeyObject;
+export declare const verifySignatureWithKey: VerifySignatureWithKeyFn;
+export {};