roar-firekit
v6.1.7
Published
A library to facilitate Firebase authentication and Cloud Firestore interaction for ROAR apps
Downloads
16
Maintainers
Readme
roar-firekit
Welcome to roar-firekit! Roar-firekit helps you store the data from your ROAR application in Cloud Firestore.
Installation
You can install roar-firekit from npm with
npm i @bdelab/roar-firekit
Usage
Roar-firekit is agnostic about where your data comes from, but I anticipate most users will use roar-firekit with their experiments written in jsPsych.
The main entrypoint to roar-firekit's API is the [[RoarAppkit
]] class. Its
constructor expects an object with keys userInfo
, taskInfo
, and config
, where
userInfo
is a [[UserDataInAdminDb
]] object, taskInfo
is a
[[TaskVariantInput
]] object, and config
is a [[AssessmentConfigData
]] object.
Constructor inputs
userInfo
User information is encapsulated in a [[UserDataInAdminDb
]] object. Its only required
key is id
, which should be the current user's ROAR UID, which is also sometimes called the ROAR PID:
const minimalUserInfo = { id: 'roar-user-id' };
But you can supply other information about the user if you know it:
const fullUserInfo = {
id: 'roar-user-id',
birthMonth: 7,
birthYear: 2014,
classId: 'roar-class-id',
schoolId: 'roar-school-id',
districtId: 'roar-district-id',
groupId: 'roar-group-id',
userCategory: 'student',
}
taskInfo
Information about the current task is encapsulated in a [[TaskVariantInput
]] object. Here is the task information for a fictitious "Not Hotdog" task:
const taskInfo = {
taskId: 'nhd',
taskName: 'Not Hotdog',
variantName: 'Not Hotdog, one block',
taskDescription: 'A demonstration task using the hot dog / not hot dog problem',
variantDescription: 'One block, random order',
blocks: [
{
blockNumber: 1,
trialMethod: "random-without-replacement",
corpus: "pointer-to-location-of-stimulus-corpus",
},
]
}
config
The config object contains configuration information for your Firebase project. You may want to store your config object in separate javascript file (named "roarConfig.js" for this documentation). A template is provided below
export const roarConfig = {
"firebaseConfig": {
"apiKey": "insert your firebase API key here",
"authDomain": "insert your firebase auth domain here",
"projectId": "insert your firebase project ID here",
"storageBucket": "insert your firebase storage bucket here",
"messagingSenderId": "insert your firebase messaging sender ID here",
"appId": "insert your firebase app ID here",
"measurementId": "insert your firebase measurement ID here",
},
"rootDoc": ["some collection name", "some document name"],
}
firebaseConfig
To get the firebaseConfig
fields, see this article on how to retrieve your firebase config. TLDR: go directly to your project's settings, scroll down to "SDK setup and configuration," click the "Config" radio button, and copy the snippet for your app's Firebase config object.
rootDoc
The rootDoc
is an array of strings representing the document under which all ROAR data will be stored. Note that rootDoc
does not have to be in the actual root of your Cloud Firestore database.
Constructing the firekit
With the above defined input, you would construct a firekit using
import { RoarAppkit } from '@bdelab/roar-firekit';
import { roarConfig } from './roarConfig.js';
// Insert input definition code from above
const firekit = new RoarAppkit({
userInfo: minimalUserInfo,
taskInfo,
config: roarConfig,
})
Starting a run
Starting a run writes the user, task, and run information to Cloud Firestore:
await firekit.startRun();
If you are using roar-firekit with jsPsych, you should call this method before
experiment starts, either by awaiting it before the jsPsych.run
method,
await firekit.startRun();
jsPsych.run(timeline);
or by calling it as part of the on_timeline_start
callback,
const procedure = {
timeline: [trial1, trial2],
on_timeline_start: function() {
await firekit.startRun();
}
}
Writing a trial to Firestore
After starting a run, you can write individual trial data to Cloud Firestore using the writeTrial
method.
This method can be added to individual jsPsych trials by calling it from
the on_finish
function, like so:
var trial = {
type: 'image-keyboard-response',
stimulus: 'imgA.png',
on_finish: function(data) {
firekit.writeTrial(data);
}
};
Or you can call it from all trials in a jsPsych
timeline by calling it from the on_data_update
callback. In this
case, you can avoid saving extraneous trials by conditionally calling
this method based on the data. For example:
initJsPsych({
on_data_update: function(data) {
if (data.saveToFirestore) {
firekit.addTrialData(data);
}
}
});
const timeline = [
// A fixation trial; don't save to Firestore
{
type: htmlKeyboardResponse,
stimulus: '<div style="font-size:60px;">+</div>',
choices: "NO_KEYS",
trial_duration: 500,
},
// A stimulus and response trial; save to Firestore
{
type: imageKeyboardResponse,
stimulus: 'imgA.png',
data: { saveToFirestore: true },
}
]
Finishing a run
After your experiment is over, you can mark it as completed in Firestore using the finishRun
method. For example, you can call this method in the on_finish
(experiment) callback:
initJsPsych({
on_finish: function(data) {
firekit.finishRun();
}
});
Full example
The following is an example jsPsych experiment that implements the NoHotdog assessment while writing data to Cloud Firestore using roar-firekit.
import { initJsPsych } from 'jspsych';
import preload from '@jspsych/plugin-preload';
import htmlKeyboardResponse from '@jspsych/plugin-html-keyboard-response';
import imageButtonResponse from '@jspsych/plugin-image-button-response';
import { RoarAppkit } from '@bdelab/roar-firekit';
import { roarConfig } from "./roarConfig.js";
const taskInfo = {
taskId: 'nhd',
taskName: 'Not Hotdog',
variantName: 'nhd-1block-random',
taskDescription: 'A ROAR demonstration using the hot dog / not hot dog task.',
variantDescription: 'One block, random order',
blocks: [
{
blockNumber: 1,
trialMethod: 'random-without-replacement',
corpus: 'assets',
},
],
};
const minimalUserInfo = { id: 'roar-user-id' };
const firekit = new RoarAppkit({
userInfo: minimalUserInfo,
taskInfo,
config: roarConfig,
});
await firekit.startRun();
const jsPsych = initJsPsych({
on_data_update: function (data) {
if (data.saveToFirestore) {
firekit.writeTrial(data);
}
},
on_finish: function () {
firekit.finishRun();
},
});
// This example assumes that the hot dog / not hot dog images are stored in the
// assets folder.
const numFiles = 30;
const hotDogFiles = Array.from(Array(numFiles), (_, i) => i + 1).map(
(idx) => new URL(`../assets/hotdog/${idx}.jpg`, import.meta.url),
);
const notHotDogFiles = Array.from(Array(numFiles), (_, i) => i + 1).map(
(idx) => new URL(`../assets/nothotdog/${idx}.jpg`, import.meta.url),
);
const allFiles = hotDogFiles.concat(notHotDogFiles);
const allTargets = allFiles.map((url) => {
return { target: url, isHotDog: !url.pathname.includes('nothotdog') };
});
let timeline = [];
/* preload images */
const preloadImages = {
type: preload,
auto_preload: true,
};
timeline.push(preloadImages);
/* define welcome message trial */
const welcome = {
type: htmlKeyboardResponse,
stimulus: 'Welcome to ROAR-HD, a rapid online assessment of hot dog differentiating ability. Press any key to begin.',
};
timeline.push(welcome);
const hotDogTrials = {
timeline: [
{
type: htmlKeyboardResponse,
stimulus: '<div style="font-size:60px;">+</div>',
choices: 'NO_KEYS',
trial_duration: 500,
},
{
type: imageButtonResponse,
stimulus: jsPsych.timelineVariable('target'),
choices: ['Hot Dog', 'Not a Hot Dog'],
prompt: 'Is this a hot dog?',
data: { saveToFirestore: true },
on_finish: function (data) {
data.correct = jsPsych.timelineVariable('isHotDog') == data.response;
},
},
],
timeline_variables: allTargets,
sample: {
type: 'without-replacement',
size: 20,
},
};
timeline.push(hotDogTrials);
const fixation = {
type: htmlKeyboardResponse,
stimulus: 'You are all done. Thanks!',
choices: 'NO_KEYS',
};
timeline.push(fixation);
jsPsych.run(timeline);