settling on NexBases

src/nex-runtime/NexLmsApiProvider.js

@@ -1,31 +0,0 @@
-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-runtime/NexLmsDataProvider.js

@@ -0,0 +1,26 @@
+import { getConfig } from '@edx/frontend-platform';
+import { getAuthenticatedHttpClient } from '@edx/frontend-platform/auth';
+import { NexDataProvider } from '../nex/NexBases';
+
+export default class NexLmsDataProvider extends NexDataProvider  {
+
+	constructor(nexApiRoot, instanceKey, learningContextKey) {
+		super(instanceKey, learningContextKey);
+		this.client = getAuthenticatedHttpClient();
+		this.instanceDataRoot = `${nexApiRoot}/instances/${instanceKey}`;
+		this.learnerDataRoot = `${nexApiRoot}/instances/${instanceKey}/contexts/${learningContextKey}`;
+	}
+
+	async fetchInstanceData(dataKey) {
+		return this.client.get(`${this.instanceDataRoot}/data/${dataKey || ''}`);
+	}
+
+	async fetchLearnerData(dataKey) {
+		return this.client.get(`${this.learnerDataRoot}/data/${dataKey}`);
+	}
+
+	async emitLearnerEvent(eventData) {
+		return this.client.post(`${this.learnerDataRoot}/events`, eventData);
+	}
+
+}

src/nex/NexBases.js

@@ -1,61 +1,57 @@
 
+import PropTypes from 'prop-types';
 
-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 {
+export class NexDataProvider {
 
 	constructor(instanceKey, learningContextKey) {
 		this.instanceKey = instanceKey;
 		this.learningContextKey = learningContextKey;
 	}
 
-	async fetchInstanceData(key) {
-		throw new Error("NexApiProvider.fetchInstanceData must be implemented.");
+	async fetchInstanceData(dataKey) {
+		throw new Error("NexDataProvider.fetchInstanceData must be implemented.")
 	}
 
-	async fetchLearnerData(key) {
-		throw new Error("NexApiProvider.fetchLearnerData must be implemented.");
+	async fetchLearnerData(dataKey) {
+		throw new Error("NexDataProvider.fetchLearnerData must be implemented.")
 	}
 
-	async emitLearnerEvent(learner, event) {
-		throw new Error("NexApiProvider.emitLearnerEvent must be implemented.");
+	async emitLearnerEvent(eventData) {
+		throw new Error("NexDataProvider.emitLearnerEvent must be implemented.")
 	}
-
 }
 
+export class NexCore {
+
+	constructor(dataProvider) {
+		this.dataProvider = dataProvider;
+	}
+	
+	async query(queryData) {
+		throw new Error("NexCore.query must be implemented.")
+	}
+}
+
+export function NexBlock({core, learnerUi, instructorUi, authorUi, instanceDataSchema}) {
+	const injectCoreIntoProps = ui => (props => ui({core, ...props}));
+
+	this.learnerUi = injectCoreIntoProps(learnerUi);
+	this.instructorUi = instructorUi ? injectCoreIntoProps(instructorUi) : this.learnerUi;
+	this.authorUi = authorUi || FallbackAuthoringUi(instanceDataSchema || null);
+}
+
+NexBlock.propTypes = {
+	core: PropTypes.instanceOf(NexCore).isRequired,
+	learnerUi: PropTypes.elementType.isRequired,
+	instructorUi: PropTypes.elementType,
+	authorUi: PropTypes.elementType,
+	instanceDataSchema: PropTypes.object,
+}
+
+function FallbackAuthoringUi({instanceDataSchema}) {
+	return "Fallback Authoring UI not yet implemented";
+}
+
+FallbackAuthoringUi.propTypes = {
+	instanceDataSchema: PropTypes.object;
+}

src/nex/NexBasesForReact.js

@@ -1,40 +0,0 @@
-
-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);
-		}
-	}
-
-}