ideating on nex base classes

.env

@@ -29,5 +29,4 @@ SUPPORT_URL_VERIFIED_CERTIFICATE=null
 TWITTER_HASHTAG=null
 TWITTER_URL=null
 USER_INFO_COOKIE_NAME=null
-NEXBLOCK_INSTANCE_DATA_API_PATH=null
-NEXBLOCK_LEARNER_DATA_API_PATH=null
+NEXBLOCK_API_PATH=null

src/index.jsx

@@ -96,8 +96,7 @@ initialize({
         SUPPORT_URL_VERIFIED_CERTIFICATE: process.env.SUPPORT_URL_VERIFIED_CERTIFICATE || null,
         TWITTER_HASHTAG: process.env.TWITTER_HASHTAG || null,
         TWITTER_URL: process.env.TWITTER_URL || null,
-        NEXBLOCK_INSTANCE_DATA_API_PATH: process.env.NEXBLOCK_INSTANCE_DATA_API_PATH || null,
-        NEXBLOCK_LEARNER_DATA_API_PATH: process.env.NEXBLOCK_LEARNER_DATA_API_PATH || null,
+        NEXBLOCK_API_PATH: process.env.NEXBLOCK_API_PATH || null,
       }, 'LearnerAppConfig');
     },
   },

src/nex-runtime/NexLmsApiProvider.js

@@ -0,0 +1,31 @@
+import { getConfig } from '@edx/frontend-platform';
+import { getAuthenticatedHttpClient } from '@edx/frontend-platform/auth';
+import { NexApiProvider } from '../NexBases';
+
+export default class NexLmsApiProvider extends NexApiProvider {
+
+	constructor(instanceKey, learningContextKey) {
+		super(instanceKey, learningContextKey);
+		this.client = getAuthenticatedHttpClient();
+		const apiRoot = getConfig().NEXBLOCK_API_PATH;
+		this.instanceRoot = `${this.apiPath}/instances/${this.instanceKey}`;
+		this.contextRoot = `${this.instanceRoot}/contexts/${this.learningContextKey}`;
+	}
+
+	async fetchInstanceData(key) {
+		const theKey = key ?? '';
+		const url = `${this.instanceRoot}/data/${theKey}`;
+		return this.client.get(url);
+	}
+
+	async fetchLearnerData(key) {
+		const url = `${this.contextRoot}/data/${key}`;
+		return this.client.get(url);
+	}
+
+	async emitLearnerEvent(key) {
+		const url = `${this.contextRoot}/events`;
+		return this.client.post(url);
+	}
+
+}

src/nex/NexBases.js

@@ -0,0 +1,61 @@
+
+
+function renderFallbackAuthoringUiTo(nexBlock, element) {
+	throw new Error("renderFallbackAuthoringUiTo not yet implemented.");
+}
+
+export class NexBlock {
+
+	renderLearnerUiTo(element) {
+		throw new Error("NexBlock.renderLearnerUiTo must be implemented.");
+	}
+
+	renderInstructorUiTo(element) {
+		return this.renderLearnerUiTo(element);
+	}
+
+	renderAuthorUiTo(element) {
+		renderFallbackAuthoringUi(this, element);
+	}
+
+	getCoreClass() {
+		if(this.constructor.Core ) { return this.constructor.Core; } else {
+			throw new Error("NexBlock.Core must be defined");
+		}
+	}
+}
+
+
+export class NexCore {
+
+	constructor(nexApiProvider) {
+		this._nexApiProvider = nexApiProvider
+	}
+
+	async query(requestData) {
+		throw new Error("NexCore.query must be implemented.");
+	}
+}
+
+
+export class NexApiProvider {
+
+	constructor(instanceKey, learningContextKey) {
+		this.instanceKey = instanceKey;
+		this.learningContextKey = learningContextKey;
+	}
+
+	async fetchInstanceData(key) {
+		throw new Error("NexApiProvider.fetchInstanceData must be implemented.");
+	}
+
+	async fetchLearnerData(key) {
+		throw new Error("NexApiProvider.fetchLearnerData must be implemented.");
+	}
+
+	async emitLearnerEvent(learner, event) {
+		throw new Error("NexApiProvider.emitLearnerEvent must be implemented.");
+	}
+
+}
+

src/nex/NexBasesForReact.js

@@ -0,0 +1,40 @@
+
+import React from 'react';
+import { NexBlock } from './NexBases';
+
+export function NexBlockComponent({learnerComponent, instructorComponent, authorComponent}) {
+
+	constructor(props) {
+		super(core, instanceSchema);
+		this.learnerComponent = learnerComponentClass({});
+		this.instructorComponent = instructorComponentClass({});
+		this.authorComponent = authorComponentClass({});
+	}
+
+	asVanillaNexBlock() {
+
+	}
+
+
+}
+
+export class ReactNexBlock {
+
+
+	renderLearnerUiTo(element) {
+		React.render(this.learnerComponent, element);
+	}
+
+	renderInstructorUiTo(element) {
+		React.render(this.instructorComponent || this.learnerComponent, element);
+	}
+
+	renderAuthorUiTo(element) {
+		if (this.authorComponent) { 
+			React.render(this.authorComponent, element);
+		} else {
+			return super.renderAuthorUiTo(element);
+		}
+	}
+
+}

src/nexblocks/NexBlockApiProvider.js

@@ -1,16 +0,0 @@
-import { getConfig } from '@edx/frontend-platform';
-import { getAuthenticatedHttpClient } from '@edx/frontend-platform/auth';
-
-export default class NexBlockApiProvider {
-
-	constructor(learningContextId, instanceId) {
-
-	}
-
-	async getInstanceData() {
-		const httpClient = getAuthenticatedHttpClient();
-		const baseUrl = getConfig().NEXBLOCK_INSTANCE_DATA_API_URL;
-		return httpClient.get(`${baseUrl}/`);
-	}
-
-}