strapi-plugin-radiocult-uploader 1.0.0

package/dist/server/src/bootstrap.d.ts

@@ -0,0 +1,5 @@
+import { Core } from '@strapi/strapi';
+declare const bootstrap: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => Promise<void>;
+export default bootstrap;

package/dist/server/src/config/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Plugin config. Values set here (usually from env vars via the app's
+ * config/plugins.ts, or the defaults below which read the RADIOCULT_* env
+ * vars directly) override whatever is stored via the settings page — secrets
+ * managed at the hosting level always win.
+ */
+declare const _default: {
+    default: ({ env }: {
+        env: (key: string, fallback?: unknown) => any;
+    }) => {
+        apiKey: any;
+        stationId: any;
+        enabled: any;
+    };
+    validator(): void;
+};
+export default _default;

package/dist/server/src/content-types/index.d.ts

@@ -0,0 +1,51 @@
+declare const _default: {
+    'track-record': {
+        schema: {
+            kind: string;
+            collectionName: string;
+            info: {
+                singularName: string;
+                pluralName: string;
+                displayName: string;
+                description: string;
+            };
+            options: {
+                draftAndPublish: boolean;
+            };
+            pluginOptions: {
+                "content-manager": {
+                    visible: boolean;
+                };
+                "content-type-builder": {
+                    visible: boolean;
+                };
+            };
+            attributes: {
+                contentTypeUid: {
+                    type: string;
+                    required: boolean;
+                };
+                entryDocumentId: {
+                    type: string;
+                    required: boolean;
+                };
+                trackId: {
+                    type: string;
+                };
+                uploadedAt: {
+                    type: string;
+                };
+                mixcloudRequestedAt: {
+                    type: string;
+                };
+                soundcloudRequestedAt: {
+                    type: string;
+                };
+                lastSyncedAt: {
+                    type: string;
+                };
+            };
+        };
+    };
+};
+export default _default;

package/dist/server/src/content-types/track-record/schema.json.d.ts

@@ -0,0 +1,29 @@
+declare const _default: {
+  "kind": "collectionType",
+  "collectionName": "radiocult_track_records",
+  "info": {
+    "singularName": "track-record",
+    "pluralName": "track-records",
+    "displayName": "Radio Cult Track Record",
+    "description": "Bookkeeping for tracks uploaded to Radio Cult (managed by the Radio Cult Uploader plugin)"
+  },
+  "options": {
+    "draftAndPublish": false
+  },
+  "pluginOptions": {
+    "content-manager": { "visible": false },
+    "content-type-builder": { "visible": false }
+  },
+  "attributes": {
+    "contentTypeUid": { "type": "string", "required": true },
+    "entryDocumentId": { "type": "string", "required": true },
+    "trackId": { "type": "string" },
+    "uploadedAt": { "type": "datetime" },
+    "mixcloudRequestedAt": { "type": "datetime" },
+    "soundcloudRequestedAt": { "type": "datetime" },
+    "lastSyncedAt": { "type": "datetime" }
+  }
+}
+;
+
+export default _default;

package/dist/server/src/controllers/index.d.ts

@@ -0,0 +1,21 @@
+declare const _default: {
+    uploader: ({ strapi }: {
+        strapi: import('@strapi/types/dist/core').Strapi;
+    }) => {
+        upload: (ctx: any) => Promise<void>;
+        publish: (ctx: any) => Promise<void>;
+        updateTrack: (ctx: any) => Promise<void>;
+        status: (ctx: any) => Promise<void>;
+    };
+    settings: ({ strapi }: {
+        strapi: import('@strapi/types/dist/core').Strapi;
+    }) => {
+        get: (ctx: any) => Promise<void>;
+        update: (ctx: any) => Promise<void>;
+        testConnection: (ctx: any) => Promise<void>;
+        uiConfig: (ctx: any) => Promise<void>;
+        contentTypes: (ctx: any) => Promise<void>;
+        diagnostics: (ctx: any) => Promise<void>;
+    };
+};
+export default _default;

package/dist/server/src/controllers/settings.d.ts

@@ -0,0 +1,16 @@
+import { Core } from '@strapi/strapi';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    get: (ctx: any) => Promise<void>;
+    update: (ctx: any) => Promise<void>;
+    testConnection: (ctx: any) => Promise<void>;
+    /**
+     * Theme + mapped content type — readable by any admin (the uploader page
+     * needs the theme, the edit-view side panel needs the content type).
+     */
+    uiConfig: (ctx: any) => Promise<void>;
+    contentTypes: (ctx: any) => Promise<void>;
+    diagnostics: (ctx: any) => Promise<void>;
+};
+export default _default;

package/dist/server/src/controllers/uploader.d.ts

@@ -0,0 +1,10 @@
+import { Core } from '@strapi/strapi';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    upload: (ctx: any) => Promise<void>;
+    publish: (ctx: any) => Promise<void>;
+    updateTrack: (ctx: any) => Promise<void>;
+    status: (ctx: any) => Promise<void>;
+};
+export default _default;

package/dist/server/src/controllers/utils.d.ts

@@ -0,0 +1,16 @@
+type Handler = (ctx: any) => Promise<unknown>;
+/**
+ * Wraps a handler with error → HTTP response mapping and detailed logging:
+ * every failure is logged with method, path, admin user and status; 5xx also
+ * get the stack trace.
+ */
+export declare const respond: (fn: Handler) => (ctx: any) => Promise<void>;
+/** Edited-details fields, from either a multipart or a JSON body. */
+export declare const metaFrom: (body: any) => {
+    title: any;
+    artist: any;
+    album: any;
+    description: any;
+    tags: any;
+};
+export {};

package/dist/server/src/destroy.d.ts

@@ -0,0 +1,5 @@
+import { Core } from '@strapi/strapi';
+declare const destroy: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default destroy;

package/dist/server/src/index.d.ts

@@ -0,0 +1,267 @@
+declare const _default: {
+    register: ({ strapi }: {
+        strapi: import('@strapi/types/dist/core').Strapi;
+    }) => void;
+    bootstrap: ({ strapi }: {
+        strapi: import('@strapi/types/dist/core').Strapi;
+    }) => Promise<void>;
+    destroy: ({ strapi }: {
+        strapi: import('@strapi/types/dist/core').Strapi;
+    }) => void;
+    config: {
+        default: ({ env }: {
+            env: (key: string, fallback?: unknown) => any;
+        }) => {
+            apiKey: any;
+            stationId: any;
+            enabled: any;
+        };
+        validator(): void;
+    };
+    controllers: {
+        uploader: ({ strapi }: {
+            strapi: import('@strapi/types/dist/core').Strapi;
+        }) => {
+            upload: (ctx: any) => Promise<void>;
+            publish: (ctx: any) => Promise<void>;
+            updateTrack: (ctx: any) => Promise<void>;
+            status: (ctx: any) => Promise<void>;
+        };
+        settings: ({ strapi }: {
+            strapi: import('@strapi/types/dist/core').Strapi;
+        }) => {
+            get: (ctx: any) => Promise<void>;
+            update: (ctx: any) => Promise<void>;
+            testConnection: (ctx: any) => Promise<void>;
+            uiConfig: (ctx: any) => Promise<void>;
+            contentTypes: (ctx: any) => Promise<void>;
+            diagnostics: (ctx: any) => Promise<void>;
+        };
+    };
+    routes: {
+        admin: {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: {
+                        name: string;
+                        config: {
+                            actions: string[];
+                        };
+                    }[];
+                };
+            }[];
+        };
+    };
+    services: {
+        settings: ({ strapi }: {
+            strapi: import('@strapi/types/dist/core').Strapi;
+        }) => {
+            store(): {
+                get(params?: Partial<{
+                    key: string;
+                    type?: string;
+                    environment?: string;
+                    name?: string;
+                    tag?: string;
+                }>): Promise<unknown>;
+                set(params?: Partial<{
+                    key: string;
+                    value: unknown;
+                    type?: string;
+                    environment?: string;
+                    name?: string;
+                    tag?: string;
+                }>): Promise<void>;
+                delete(params?: Partial<{
+                    key: string;
+                    type?: string;
+                    environment?: string;
+                    name?: string;
+                    tag?: string;
+                }>): Promise<void>;
+            };
+            get(): Promise<import('./services/settings').PluginSettings>;
+            envLocks(): {
+                apiKey: boolean;
+                stationId: boolean;
+                enabled: boolean;
+            };
+            credentials(): Promise<{
+                apiKey: string;
+                stationId: string;
+                enabled: boolean;
+            }>;
+            validateMapping(mapping: import('./services/settings').FieldMap): void;
+            update(patch: Partial<import('./services/settings').PluginSettings>): Promise<import('./services/settings').PluginSettings>;
+            testConnection(): Promise<{
+                ok: boolean;
+                message: string;
+            }>;
+        };
+        mapping: ({ strapi }: {
+            strapi: import('@strapi/types/dist/core').Strapi;
+        }) => {
+            settings(): import('@strapi/types/dist/core').Service;
+            mapping(): Promise<import('./services/settings').FieldMap>;
+            requireMapping(): Promise<import('./services/settings').FieldMap>;
+            populateFor(mapping: import('./services/settings').FieldMap): Record<string, true>;
+            normalise(mapping: import('./services/settings').FieldMap, entry: any): import('./services/mapping').NormalisedEntry;
+            loadEntry(documentId: string): Promise<import('./services/mapping').NormalisedEntry>;
+            writeLinks(documentId: string, links: Partial<Record<import('./utils/plugin').Platform, string>>): Promise<string[]>;
+            listContentTypes(): {
+                uid: string;
+                displayName: any;
+                attributes: {
+                    name: string;
+                    type: any;
+                    target: any;
+                    targetAttributes: string[];
+                }[];
+            }[];
+        };
+        records: ({ strapi }: {
+            strapi: import('@strapi/types/dist/core').Strapi;
+        }) => {
+            find(contentTypeUid: string, entryDocumentId: string): Promise<import('./services/records').TrackRecord | null>;
+            upsert(contentTypeUid: string, entryDocumentId: string, data: Partial<import('./services/records').TrackRecord>): Promise<import('./services/records').TrackRecord>;
+            findUploaded(contentTypeUid: string, entryDocumentIds?: string[]): Promise<import('./services/records').TrackRecord[]>;
+        };
+        radiocult: ({ strapi }: {
+            strapi: import('@strapi/types/dist/core').Strapi;
+        }) => {
+            uploadTrack({ documentId, file, force, meta, }: {
+                documentId: string;
+                file: any;
+                force: boolean;
+                meta?: {
+                    title?: string;
+                    artist?: string;
+                    album?: string;
+                };
+            }): Promise<{
+                trackId: any;
+                warnings: string[];
+            }>;
+            publish({ documentId, platform, force, meta, }: {
+                documentId: string;
+                platform: string;
+                force: boolean;
+                meta?: {
+                    title?: string;
+                    tags?: unknown;
+                    description?: string;
+                };
+            }): Promise<{
+                requestedAt: string;
+            }>;
+            syncLinks({ documentIds, bypassCache, }?: {
+                documentIds?: string[];
+                bypassCache?: boolean;
+            }): Promise<{
+                updated: number;
+                pending: number;
+            }>;
+            getStatus(documentId: string, { refresh }?: {
+                refresh?: boolean;
+            }): Promise<{
+                enabled: boolean;
+                trackId: any;
+                uploadedAt: any;
+                platforms: {
+                    mixcloud: {
+                        state: "not_published" | "publishing" | "linked" | "stalled";
+                        requestedAt: string;
+                        link: string;
+                    };
+                    soundcloud: {
+                        state: "not_published" | "publishing" | "linked" | "stalled";
+                        requestedAt: string;
+                        link: string;
+                    };
+                };
+                rateLimitMessage: string;
+                details: {
+                    title: any;
+                    showName: any;
+                    artist: any;
+                    album: string;
+                    description: any;
+                    genres: any;
+                    image: {
+                        name: any;
+                        previewUrl: any;
+                        usable: boolean;
+                    };
+                };
+            }>;
+            updateTrackMetadata({ documentId, meta, }: {
+                documentId: string;
+                meta: {
+                    title?: string;
+                    artist?: string;
+                    album?: string;
+                };
+            }): Promise<{
+                updated: string[];
+            }>;
+            maybeSyncTitle(event: any): Promise<void>;
+        };
+    };
+    contentTypes: {
+        'track-record': {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    description: string;
+                };
+                options: {
+                    draftAndPublish: boolean;
+                };
+                pluginOptions: {
+                    "content-manager": {
+                        visible: boolean;
+                    };
+                    "content-type-builder": {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    contentTypeUid: {
+                        type: string;
+                        required: boolean;
+                    };
+                    entryDocumentId: {
+                        type: string;
+                        required: boolean;
+                    };
+                    trackId: {
+                        type: string;
+                    };
+                    uploadedAt: {
+                        type: string;
+                    };
+                    mixcloudRequestedAt: {
+                        type: string;
+                    };
+                    soundcloudRequestedAt: {
+                        type: string;
+                    };
+                    lastSyncedAt: {
+                        type: string;
+                    };
+                };
+            };
+        };
+    };
+    policies: {};
+    middlewares: {};
+};
+export default _default;

package/dist/server/src/middlewares/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/server/src/policies/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/server/src/register.d.ts

@@ -0,0 +1,5 @@
+import { Core } from '@strapi/strapi';
+declare const register: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default register;

package/dist/server/src/routes/admin/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Admin-typed routes: Strapi requires a valid admin session (Bearer JWT) on
+ * every call, and plugin routes are mounted under /radiocult-uploader.
+ * Settings routes additionally require the plugin's settings permission.
+ */
+declare const _default: {
+    type: string;
+    routes: {
+        method: string;
+        path: string;
+        handler: string;
+        config: {
+            policies: {
+                name: string;
+                config: {
+                    actions: string[];
+                };
+            }[];
+        };
+    }[];
+};
+export default _default;

package/dist/server/src/routes/index.d.ts

@@ -0,0 +1,19 @@
+declare const _default: {
+    admin: {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                policies: {
+                    name: string;
+                    config: {
+                        actions: string[];
+                    };
+                }[];
+            };
+        }[];
+    };
+};
+export default _default;

package/dist/server/src/services/id3.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Embeds artwork into an mp3's ID3v2 tag without loading the audio into
+ * memory. Radio Cult has no artwork API — it only reads the art embedded in
+ * the uploaded file — so this runs on every mp3 upload that has an episode
+ * image. Any existing ID3v2 tag is replaced (audio frames are untouched).
+ */
+/**
+ * Writes a copy of `srcPath` with a fresh ID3v2 tag (title + front-cover
+ * artwork) into the OS temp dir and returns the new file's path. The caller
+ * is responsible for deleting the returned file.
+ */
+export declare function embedArtworkMp3(srcPath: string, opts: {
+    title: string;
+    artist: string;
+    album: string;
+    imageBuffer: Buffer;
+    imageMime: string;
+}): Promise<string>;

package/dist/server/src/services/index.d.ts

@@ -0,0 +1,156 @@
+declare const _default: {
+    settings: ({ strapi }: {
+        strapi: import('@strapi/types/dist/core').Strapi;
+    }) => {
+        store(): {
+            get(params?: Partial<{
+                key: string;
+                type?: string;
+                environment?: string;
+                name?: string;
+                tag?: string;
+            }>): Promise<unknown>;
+            set(params?: Partial<{
+                key: string;
+                value: unknown;
+                type?: string;
+                environment?: string;
+                name?: string;
+                tag?: string;
+            }>): Promise<void>;
+            delete(params?: Partial<{
+                key: string;
+                type?: string;
+                environment?: string;
+                name?: string;
+                tag?: string;
+            }>): Promise<void>;
+        };
+        get(): Promise<import('./settings').PluginSettings>;
+        envLocks(): {
+            apiKey: boolean;
+            stationId: boolean;
+            enabled: boolean;
+        };
+        credentials(): Promise<{
+            apiKey: string;
+            stationId: string;
+            enabled: boolean;
+        }>;
+        validateMapping(mapping: import('./settings').FieldMap): void;
+        update(patch: Partial<import('./settings').PluginSettings>): Promise<import('./settings').PluginSettings>;
+        testConnection(): Promise<{
+            ok: boolean;
+            message: string;
+        }>;
+    };
+    mapping: ({ strapi }: {
+        strapi: import('@strapi/types/dist/core').Strapi;
+    }) => {
+        settings(): import('@strapi/types/dist/core').Service;
+        mapping(): Promise<import('./settings').FieldMap>;
+        requireMapping(): Promise<import('./settings').FieldMap>;
+        populateFor(mapping: import('./settings').FieldMap): Record<string, true>;
+        normalise(mapping: import('./settings').FieldMap, entry: any): import('./mapping').NormalisedEntry;
+        loadEntry(documentId: string): Promise<import('./mapping').NormalisedEntry>;
+        writeLinks(documentId: string, links: Partial<Record<import('../utils/plugin').Platform, string>>): Promise<string[]>;
+        listContentTypes(): {
+            uid: string;
+            displayName: any;
+            attributes: {
+                name: string;
+                type: any;
+                target: any;
+                targetAttributes: string[];
+            }[];
+        }[];
+    };
+    records: ({ strapi }: {
+        strapi: import('@strapi/types/dist/core').Strapi;
+    }) => {
+        find(contentTypeUid: string, entryDocumentId: string): Promise<import('./records').TrackRecord | null>;
+        upsert(contentTypeUid: string, entryDocumentId: string, data: Partial<import('./records').TrackRecord>): Promise<import('./records').TrackRecord>;
+        findUploaded(contentTypeUid: string, entryDocumentIds?: string[]): Promise<import('./records').TrackRecord[]>;
+    };
+    radiocult: ({ strapi }: {
+        strapi: import('@strapi/types/dist/core').Strapi;
+    }) => {
+        uploadTrack({ documentId, file, force, meta, }: {
+            documentId: string;
+            file: any;
+            force: boolean;
+            meta?: {
+                title?: string;
+                artist?: string;
+                album?: string;
+            };
+        }): Promise<{
+            trackId: any;
+            warnings: string[];
+        }>;
+        publish({ documentId, platform, force, meta, }: {
+            documentId: string;
+            platform: string;
+            force: boolean;
+            meta?: {
+                title?: string;
+                tags?: unknown;
+                description?: string;
+            };
+        }): Promise<{
+            requestedAt: string;
+        }>;
+        syncLinks({ documentIds, bypassCache, }?: {
+            documentIds?: string[];
+            bypassCache?: boolean;
+        }): Promise<{
+            updated: number;
+            pending: number;
+        }>;
+        getStatus(documentId: string, { refresh }?: {
+            refresh?: boolean;
+        }): Promise<{
+            enabled: boolean;
+            trackId: any;
+            uploadedAt: any;
+            platforms: {
+                mixcloud: {
+                    state: "not_published" | "publishing" | "linked" | "stalled";
+                    requestedAt: string;
+                    link: string;
+                };
+                soundcloud: {
+                    state: "not_published" | "publishing" | "linked" | "stalled";
+                    requestedAt: string;
+                    link: string;
+                };
+            };
+            rateLimitMessage: string;
+            details: {
+                title: any;
+                showName: any;
+                artist: any;
+                album: string;
+                description: any;
+                genres: any;
+                image: {
+                    name: any;
+                    previewUrl: any;
+                    usable: boolean;
+                };
+            };
+        }>;
+        updateTrackMetadata({ documentId, meta, }: {
+            documentId: string;
+            meta: {
+                title?: string;
+                artist?: string;
+                album?: string;
+            };
+        }): Promise<{
+            updated: string[];
+        }>;
+        maybeSyncTitle(event: any): Promise<void>;
+    };
+};
+export default _default;