strapi-plugin-radiocult-uploader 1.0.0

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

@@ -0,0 +1,47 @@
+import { Core } from '@strapi/strapi';
+import { FieldMap } from './settings';
+import { Platform } from '../utils/plugin';
+export interface NormalisedEntry {
+    documentId: string;
+    title: string;
+    image: any | null;
+    broadcastDate: string | null;
+    tags: string[];
+    showName: string;
+    links: Record<Platform, string | null>;
+    raw: any;
+}
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    settings(): Core.Service;
+    mapping(): Promise<FieldMap>;
+    /** Throws 503 until a content type + title field have been mapped. */
+    requireMapping(): Promise<FieldMap>;
+    /** Populate object covering every mapped relation/media field. */
+    populateFor(mapping: FieldMap): Record<string, true>;
+    normalise(mapping: FieldMap, entry: any): NormalisedEntry;
+    /** Loads one mapped entry (with relations populated) or throws 404. */
+    loadEntry(documentId: string): Promise<NormalisedEntry>;
+    /**
+     * Writes platform links back onto the user's entry. Only the mapped link
+     * fields are touched. Uses the db layer (like the pre-plugin code) so the
+     * write lands directly on the stored row without a draft/publish cycle.
+     */
+    writeLinks(documentId: string, links: Partial<Record<Platform, string>>): Promise<string[]>;
+    /**
+     * Content types + attributes for the settings page's mapping selects.
+     * Only user-created (api::) types; attributes reduced to what the UI needs.
+     */
+    listContentTypes(): {
+        uid: string;
+        displayName: any;
+        attributes: {
+            name: string;
+            type: any;
+            target: any;
+            targetAttributes: string[];
+        }[];
+    }[];
+};
+export default _default;

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

@@ -0,0 +1,115 @@
+import { Core } from '@strapi/strapi';
+type PlatformState = 'not_published' | 'publishing' | 'linked' | 'stalled';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    /**
+     * Receives the browser upload (a formidable temp file), embeds artwork
+     * for mp3s, forwards the file to Radio Cult and stores the returned track
+     * id in the plugin's track-record. `meta` carries the (possibly edited)
+     * details from the uploader page; anything missing falls back to the
+     * entry's own values.
+     */
+    uploadTrack({ documentId, file, force, meta, }: {
+        documentId: string;
+        file: any;
+        force: boolean;
+        meta?: {
+            title?: string;
+            artist?: string;
+            album?: string;
+        };
+    }): Promise<{
+        trackId: any;
+        warnings: string[];
+    }>;
+    /**
+     * Asks Radio Cult to publish the entry's track to Mixcloud or SoundCloud.
+     * Radio Cult transfers asynchronously; syncLinks picks up the URL later.
+     * `meta` carries the (possibly edited) details from the uploader page.
+     */
+    publish({ documentId, platform, force, meta, }: {
+        documentId: string;
+        platform: string;
+        force: boolean;
+        meta?: {
+            title?: string;
+            tags?: unknown;
+            description?: string;
+        };
+    }): Promise<{
+        requestedAt: string;
+    }>;
+    /**
+     * Finds entries whose publish was requested but whose link hasn't
+     * arrived, fetches Radio Cult's track list ONCE, and writes any links
+     * that appeared back onto the mapped fields. Called by the cron sweep,
+     * the status endpoint and the "check now" button.
+     */
+    syncLinks({ documentIds, bypassCache, }?: {
+        documentIds?: string[];
+        bypassCache?: boolean;
+    }): Promise<{
+        updated: number;
+        pending: number;
+    }>;
+    /**
+     * Per-entry state for the panel and the uploader page. Includes the
+     * entry details the uploader page prefills its editable form with.
+     */
+    getStatus(documentId: string, { refresh }?: {
+        refresh?: boolean;
+    }): Promise<{
+        enabled: boolean;
+        trackId: any;
+        uploadedAt: any;
+        platforms: {
+            mixcloud: {
+                state: PlatformState;
+                requestedAt: string;
+                link: string;
+            };
+            soundcloud: {
+                state: PlatformState;
+                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;
+            };
+        };
+    }>;
+    /**
+     * Pushes edited title/artist/album to an already-uploaded Radio Cult
+     * track (the uploader page's "Save details to Radio Cult" button).
+     */
+    updateTrackMetadata({ documentId, meta, }: {
+        documentId: string;
+        meta: {
+            title?: string;
+            artist?: string;
+            album?: string;
+        };
+    }): Promise<{
+        updated: string[];
+    }>;
+    /**
+     * Lifecycle hook body: pushes a changed title to the Radio Cult track.
+     * Only fires when the mapped title field actually changed (beforeUpdate
+     * stashes the previous value) — the track title can be customised on the
+     * uploader page, and an unrelated save must not overwrite it.
+     */
+    maybeSyncTitle(event: any): Promise<void>;
+};
+export default _default;

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

@@ -0,0 +1,25 @@
+import { Core } from '@strapi/strapi';
+import { Platform } from '../utils/plugin';
+export interface TrackRecord {
+    id: number;
+    documentId: string;
+    contentTypeUid: string;
+    entryDocumentId: string;
+    trackId: string | null;
+    uploadedAt: string | null;
+    mixcloudRequestedAt: string | null;
+    soundcloudRequestedAt: string | null;
+    lastSyncedAt: string | null;
+}
+export declare const REQUESTED_AT: Record<Platform, 'mixcloudRequestedAt' | 'soundcloudRequestedAt'>;
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    /** The record for one entry, or null. */
+    find(contentTypeUid: string, entryDocumentId: string): Promise<TrackRecord | null>;
+    /** Creates or updates the record for one entry (service-level uniqueness). */
+    upsert(contentTypeUid: string, entryDocumentId: string, data: Partial<TrackRecord>): Promise<TrackRecord>;
+    /** All records with an uploaded track for the given content type. */
+    findUploaded(contentTypeUid: string, entryDocumentIds?: string[]): Promise<TrackRecord[]>;
+};
+export default _default;

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

@@ -0,0 +1,103 @@
+import { Core } from '@strapi/strapi';
+export interface FieldMap {
+    /** UID of the content type episodes live in, e.g. 'api::episode.episode'. */
+    contentType: string | null;
+    /** String field holding the episode title. */
+    title: string | null;
+    /** Media field holding the episode artwork. */
+    image: string | null;
+    /** Date/datetime field for the broadcast date (used for the default album name). */
+    broadcastDate: string | null;
+    /** String field the SoundCloud link is written back to. */
+    soundcloudLink: string | null;
+    /** String field the Mixcloud link is written back to. */
+    mixcloudLink: string | null;
+    /** Relation field holding genre/tag entries. */
+    tagsRelation: string | null;
+    /** String attribute on the tag target type used as the tag text. */
+    tagsLabelField: string | null;
+    /** Optional relation to a parent show (used for the tab title). */
+    showRelation: string | null;
+    /** String attribute on the show target type used as the show name. */
+    showLabelField: string | null;
+}
+export interface ThemeSettings {
+    preset: string;
+    /** Per-token colour overrides, e.g. { pageBg: '#C0B7AF' }. */
+    overrides: Record<string, string>;
+    /** Uploader font: 'system' or a Google font key (see admin FONTS). */
+    fontFamily: string;
+    /** Logo image URL (media library file) shown in the uploader header. */
+    logoUrl: string | null;
+    /** Station / site name shown under the uploader heading. */
+    stationName: string;
+}
+export interface PluginSettings {
+    credentials: {
+        apiKey: string;
+        stationId: string;
+        enabled: boolean;
+    };
+    mapping: FieldMap;
+    defaults: {
+        artist: string;
+        description: string;
+    };
+    theme: ThemeSettings;
+}
+export declare const DEFAULT_SETTINGS: PluginSettings;
+declare const _default: ({ strapi }: {
+    strapi: 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>;
+    };
+    /** Full settings object, stored values merged over defaults. */
+    get(): Promise<PluginSettings>;
+    /**
+     * Which credential fields are locked by plugin config / env vars. The
+     * settings page greys those inputs out and says where the value comes from.
+     */
+    envLocks(): {
+        apiKey: boolean;
+        stationId: boolean;
+        enabled: boolean;
+    };
+    /** Effective credentials: plugin config (env-backed) wins over the store. */
+    credentials(): Promise<{
+        apiKey: string;
+        stationId: string;
+        enabled: boolean;
+    }>;
+    /** Validates a mapping against the live content types. Throws RcHttpError(400). */
+    validateMapping(mapping: FieldMap): void;
+    /** Merge-updates the stored settings. Returns the new effective settings. */
+    update(patch: Partial<PluginSettings>): Promise<PluginSettings>;
+    /** Cheap authenticated Radio Cult call to prove the key + station work. */
+    testConnection(): Promise<{
+        ok: boolean;
+        message: string;
+    }>;
+};
+export default _default;

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

@@ -0,0 +1,5 @@
+/** Error with an HTTP status the admin routes pass straight to the client. */
+export declare class RcHttpError extends Error {
+    status: number;
+    constructor(status: number, message: string);
+}

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

@@ -0,0 +1,4 @@
+export declare const PLUGIN_ID = "radiocult-uploader";
+export declare const TRACK_RECORD_UID: "plugin::radiocult-uploader.track-record";
+export declare const PLATFORMS: readonly ["mixcloud", "soundcloud"];
+export type Platform = (typeof PLATFORMS)[number];

package/package.json

@@ -0,0 +1,98 @@
+{
+  "version": "1.0.0",
+  "keywords": [
+    "strapi",
+    "strapi-plugin",
+    "radiocult",
+    "radio",
+    "soundcloud",
+    "mixcloud",
+    "audio",
+    "podcast"
+  ],
+  "type": "commonjs",
+  "exports": {
+    "./package.json": "./package.json",
+    "./strapi-admin": {
+      "types": "./dist/admin/src/index.d.ts",
+      "source": "./admin/src/index.ts",
+      "import": "./dist/admin/index.mjs",
+      "require": "./dist/admin/index.js",
+      "default": "./dist/admin/index.js"
+    },
+    "./strapi-server": {
+      "types": "./dist/server/src/index.d.ts",
+      "source": "./server/src/index.ts",
+      "import": "./dist/server/index.mjs",
+      "require": "./dist/server/index.js",
+      "default": "./dist/server/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "scripts",
+    "README.md",
+    "LICENSE",
+    "logo.png"
+  ],
+  "scripts": {
+    "build": "strapi-plugin build",
+    "watch": "strapi-plugin watch",
+    "watch:link": "strapi-plugin watch:link",
+    "verify": "strapi-plugin verify",
+    "test:ts:front": "tsc -p admin/tsconfig.json --noEmit",
+    "test:ts:back": "tsc -p server/tsconfig.json --noEmit",
+    "prepublishOnly": "npm run build && npm run verify"
+  },
+  "dependencies": {
+    "node-id3": "^0.2.6"
+  },
+  "devDependencies": {
+    "@strapi/design-system": "^2.2.4",
+    "@strapi/icons": "^2.2.4",
+    "@strapi/sdk-plugin": "^6.1.1",
+    "@strapi/strapi": "^5.52.0",
+    "@strapi/typescript-utils": "^5.52.0",
+    "@types/react": "^18.3.31",
+    "@types/react-dom": "^18.3.7",
+    "prettier": "^3.9.6",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-intl": "^6.8.9",
+    "react-router-dom": "^6.30.4",
+    "styled-components": "^6.5.2",
+    "typescript": "^5.9.3",
+    "yalc": "^1.0.0-pre.53"
+  },
+  "peerDependencies": {
+    "@strapi/design-system": "^2.0.0",
+    "@strapi/icons": "^2.0.0",
+    "@strapi/strapi": "^5.0.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-intl": "^6.8.9",
+    "react-router-dom": "^6.30.4",
+    "styled-components": "^6.5.2"
+  },
+  "strapi": {
+    "kind": "plugin",
+    "name": "radiocult-uploader",
+    "displayName": "Radio Cult Uploader",
+    "description": "Upload radio show episodes to Radio Cult and publish them to SoundCloud and Mixcloud from the Strapi admin."
+  },
+  "name": "strapi-plugin-radiocult-uploader",
+  "description": "Upload radio show episodes to Radio Cult and publish them to SoundCloud and Mixcloud from the Strapi admin.",
+  "license": "MIT",
+  "author": "Tom Willis <tom.willis123456@gmail.com>",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SisterMidnightFM/Strapi-to-Radio-Cult-Plugin.git"
+  },
+  "bugs": {
+    "url": "https://github.com/SisterMidnightFM/Strapi-to-Radio-Cult-Plugin/issues"
+  },
+  "homepage": "https://github.com/SisterMidnightFM/Strapi-to-Radio-Cult-Plugin#readme"
+}

package/scripts/migrate-from-fields.mjs

@@ -0,0 +1,78 @@
+/**
+ * One-off migration for installs that previously tracked Radio Cult uploads
+ * in fields on their own content type (RadioCultTrackId & co): copies that
+ * bookkeeping into the plugin's track-record content type.
+ *
+ * Run from your Strapi app's root (after `npm run build` if the app is
+ * TypeScript):
+ *
+ *   node node_modules/strapi-plugin-radiocult-uploader/scripts/migrate-from-fields.mjs
+ *   # or from a checkout: node path/to/scripts/migrate-from-fields.mjs
+ *
+ * Configuration (env vars, defaults in brackets):
+ *   RCU_SOURCE_UID        [api::episode.episode]     content type to read from
+ *   RCU_FIELD_TRACK_ID    [RadioCultTrackId]
+ *   RCU_FIELD_UPLOADED    [RadioCultUploadedAt]
+ *   RCU_FIELD_MIX_REQ     [RadioCultMixcloudRequestedAt]
+ *   RCU_FIELD_SOUND_REQ   [RadioCultSoundcloudRequestedAt]
+ *   RCU_DRY_RUN           [false]  set to "true" to only print what would happen
+ */
+
+// Strapi's ESM build cannot be imported under Node 20+ (@strapi/core pulls in
+// lodash/fp as a directory import), so load the CommonJS build instead.
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const { createStrapi, compileStrapi } = require('@strapi/strapi');
+
+const UID = process.env.RCU_SOURCE_UID ?? 'api::episode.episode';
+const F_TRACK = process.env.RCU_FIELD_TRACK_ID ?? 'RadioCultTrackId';
+const F_UPLOADED = process.env.RCU_FIELD_UPLOADED ?? 'RadioCultUploadedAt';
+const F_MIX = process.env.RCU_FIELD_MIX_REQ ?? 'RadioCultMixcloudRequestedAt';
+const F_SOUND = process.env.RCU_FIELD_SOUND_REQ ?? 'RadioCultSoundcloudRequestedAt';
+const DRY = process.env.RCU_DRY_RUN === 'true';
+const RECORD_UID = 'plugin::radiocult-uploader.track-record';
+
+const appContext = await compileStrapi();
+const app = await createStrapi(appContext).load();
+app.log.level = 'error';
+
+try {
+  const rows = await app.db.query(UID).findMany({
+    where: { [F_TRACK]: { $notNull: true } },
+  });
+  console.log(`${rows.length} ${UID} entries with a ${F_TRACK}`);
+
+  let created = 0;
+  let skipped = 0;
+  const seen = new Set();
+  for (const row of rows) {
+    if (seen.has(row.documentId)) continue; // draft+published share a documentId
+    seen.add(row.documentId);
+
+    const existing = await app.db.query(RECORD_UID).findOne({
+      where: { contentTypeUid: UID, entryDocumentId: row.documentId },
+    });
+    if (existing) {
+      skipped += 1;
+      continue;
+    }
+    const data = {
+      contentTypeUid: UID,
+      entryDocumentId: row.documentId,
+      trackId: row[F_TRACK],
+      uploadedAt: row[F_UPLOADED] ?? null,
+      mixcloudRequestedAt: row[F_MIX] ?? null,
+      soundcloudRequestedAt: row[F_SOUND] ?? null,
+    };
+    if (DRY) {
+      console.log('would create', data);
+    } else {
+      await app.db.query(RECORD_UID).create({ data });
+    }
+    created += 1;
+  }
+  console.log(`${DRY ? 'Would create' : 'Created'} ${created} track-records, ${skipped} already existed.`);
+  console.log('Done. You can now remove the old RadioCult* fields from your schema.');
+} finally {
+  await app.destroy();
+}