How to manage documents?
jIO is mapped after the CouchDB APIs and extends them to provide unified, scalable
and high performance access via JavaScript to a wide variety of storage backends.
If you are not familiar with Apache CouchDB:
it is a scalable, fault-tolerant, and schema-free document-oriented database.
It is used in large and small organizations for a variety of applications where
traditional SQL databases are not the best solution for the problem at hand.
CouchDB provides a RESTful HTTP/JSON API accessible by many programming
libraries and tools (like curl or Pouchdb)
and has its own conflict management system.
What is a document?
A document is an association of metadata and attachment(s). The metadata is the
set of properties of the document and the attachments are binary (or text) objects
that represent the content of the document.
In jIO, the metadata is a dictionary with keys and values (a JSON object), and
attachments are simple strings.
{
// document metadata
title: 'A Title!',
creator: 'Mr.Author'
}
Here is a draft about metadata to use with jIO.
Basic Methods
Below you can see examples of the main jIO methods.
// Create a new jIO instance
var jio_instance = jIO.createJIO(storage_description);
// create and store new document
jio_instance.post({title: 'my document'}).
then(function (response) {
// console.log(response);
});
// create or update an existing document
jio_instance.put('document_name', {title: 'another document'}).
then(function (response) {
// console.log(response);
});
// add an attachment to a document
jio_instance.putAttachment('document_name',
'attachment_name',
new Blob([data], {'type' : data_mimetype});
).
then(function (response) {
// console.log(response);
});
// read a document
jio_instance.get('document_name').
then(function (response) {
// console.log(response);
});
// read an attachment
jio_instance.getAttachment('document_name',
'attachment_name').
then(function (response) {
// console.log(response);
});
// delete a document and its attachment(s)
jio_instance.remove('document_name').
then(function (response) {
// console.log(response);
});
// delete an attachment
jio_instance.removeAttachment('document_name',
'attachment_name').
then(function (response) {
// console.log(response);
});
// get all documents
jio_instance.allDocs().then(function (response) {
// console.log(response);
});
Promises
Each jIO method (with the exception of .createJIO()) returns a Promise object, which allows us to get responses into
callback parameters and to chain callbacks with other returned values.
jIO uses a custom version of RSVP.js, adding canceler and progression features.
You can read more about promises:
Method Options and Callback Responses
To retrieve jIO responses, you have to provide callbacks like this:
jio_instance.post(metadata, [options]).
then([responseCallback], [errorCallback], [progressionCallback]);
- On command success,
responseCallback is called with the jIO response as first parameter.
- On command error,
errorCallback is called with the jIO error as first parameter.
- On command notification,
progressionCallback is called with the storage notification.
Here is a list of responses returned by jIO according to methods and options:
| Available for |
Option |
Response (Callback first parameter) |
|---|
.post(), .put(), .remove() |
Any |
id of the document affected (string) |
.putAttachment(), .removeAttachment() |
Any |
no specific value |
.get() |
Any |
document_metadata (object) |
.getAttachment() |
Any |
new Blob([data], {"type": content_type})
|
.allDocs() |
No option |
{
total_rows: 1,
rows: [{
id: 'mydoc',
value: {},
}]
}
|
.allDocs() |
include_docs: true |
{
total_rows: 1,
rows: [{
id: 'mydoc',
value: {
// Here, 'mydoc' metadata
}
}]
}
|
In case of error, the errorCallback first parameter looks like:
{
status_code: 404,
message: 'Unable to get the requested document'
}
How to store binary data
The following example creates a new jIO in localStorage and then posts a document with two attachments.
// create a new jIO
var jio_instance = jIO.createJIO({type: 'indexeddb'});
// post the document 'myVideo'
jio_instance.put( 'metadata', {
title : 'My Video',
type : 'MovingImage',
format : 'video/ogg',
description : 'Images Compilation'
})
.push(undefined, function(err) {
// pushes error handler with RSVP.Queue push method
// nothing to do with JIO itself
return alert('Error posting the document metadata');
});
// post a thumbnail attachment
jio_instance.putAttachment('metadata',
'thumbnail',
new Blob([my_image], {type: 'image/jpeg'})
).push(undefined, function(err) {
return alert('Error attaching thumbnail');
});
// post video attachment
jio_instance.putAttachment('metadata',
'video',
new Blob([my_video], {type: 'video/ogg'})
).push(undefined, function(err) {
return alert('Error attaching video');
});
alert('Video Stored');
indexedDB Storage now contains:
{
"/myVideo/": {
"title": "My Video",
"type": "MovingImage",
"format": "video/ogg",
"description": "Images Compilation",
"_attachments":{
"thumbnail":{
"digest": "md5-3ue...",
"content_type": "image/jpeg",
"length": 17863
},
"video":{
"digest": "md5-0oe...",
"content_type": "video/ogg",
"length": 2840824
}
}
},
"/myVideo/thumbnail": "...",
"/myVideo/video": "..."
}
Replicate Storage: Conflicts and Resolution
Why Conflicts can Occur
Using jIO you can store documents in multiple locations. With an
increasing number of users working on a document and some storages not being
available or responding too slow, conflicts are more likely to occur. jIO
defines a conflict as multiple versions of a document existing in a storage
tree and a user trying to save on a version that does not match the latest
version of the document.
To keep track of document versions a replicate storage must be used. When doing
so, jIO creates a document tree file for every document. This file contains all
existing versions and their status and is modified whenever a version is
added/updated/removed or when storages are being synchronized.
How conflicts are handled
The RemoteStorage takes in parameter two substorages, one “local” and one “remote”.
The “local” storage can be remote, but it will be used for all the requests
like get(), getAttachment(), allDocs()…
Using the document tree, jIO tries to make every version of a document
available on the two storages. When multiple versions of a document exist,
Jio will follow the rule set by the conflict_handling option, given at storage creation.
This option can one of the following numbers:
- 0: no conflict resolution (throws an error when conflict is occuring)
- 1: keep the local state. (overwrites the remote document with local content)
- 2: keep the remote state. (overwrites the local document with remote content)
- 3: keep both copies (leave documents untouched, no signature update)
Simple Conflict Example
You are keeping a namecard file on your PC updating from your smartphone. Your
smartphone ran out of battery and is offline when you update your namecard on
your PC with your new email adress. Someone else changes this email from your PC
and once your smartphone is recharged, you go back online and the previous
update is executed.
- Set up the replicate storage:
var jio_instance = jIO.createJIO({
// replicate storage
type: 'replicate',
local_sub_storage : {
type: 'local',
...
}
remote_sub_storage: {
type: 'dav',
...
}
conflict_handling: ...
});
- Create the namecard on your smartphone:
jio_instance.put('myNameCard', {
email: 'jb@td.com'
}).then(function (response) {
// response -> 'myNameCard'
});
This will create the document on your WebDAV and local storage
- Someone else updates your shared namecard on WebDAV:
jio_instance.put('myNameCard', {
email: 'kyle@td.com',
}).then(function (response) {
// response -> 'myNameCard'
});
Your smartphone is offline, so now you will have one version on
your smartphone and another version on WebDAV on your PC.
- Later, your smartphone is online and you modify your email:
jio_instance.get('myNameCard').then(function (response) {
// response.email -> 'jb@td.com'
// the get() method checks only on your local storage
// and doesn't warn you about remote modifications.
return jio_instance.put('myNameCard', {
email: 'jack@td.com'
})
.then(function (response) {
// response -> 'myNameCard'
});
Your latest modification of the email is: “
jack@td.com”
If your conflict_handling option was:
0: the email is:
The storage rejects your latest modification,
you get an error because local and remote documents are desynchronized.
The documents in local and remote state are left untouched.
The storage pushes the local modification, which is yours.
The storage keeps the remote modification, which is from the other user.
Your local storage is modified to fit the state of the remote storage.
The storage doesn’t do synchronization, and pushes your modification
without checking if the remote storage has been changed or not
List of Available Storages
jIO saves his job queue in a workspace which is localStorage by default.
Provided storage descriptions are also stored, and it can be dangerous to
store passwords.
The best way to create a storage description is to use the (often) provided
tool given by the storage library. The returned description is secured to avoid
cleartext, readable passwords (as opposed to encrypted passwords for instance).
When building storage trees, there is no limit on the number of storages you
can use. The only thing you have to be aware of is compatibility of simple and
revision based storages.
Connectors
LocalStorage
This storage has only one document, so post, put, remove and get method are useless on it.
| parameter |
required? |
type |
description |
|---|
type |
yes |
string |
name of the storage type (here: “local”) |
sessiononly |
no |
boolean |
false: create a storage with unlimited duration.
true: the storage duration is limited to the user session.
(default to false)
|
Example:
var jio = jIO.createJIO({
type: "local",
sessiononly: true
});
MemoryStorage
Stores the data in a Javascript object, in memory.
The storage’s data isn’t saved when your web page is closed or reloaded.
The storage doesn’t take any argument at creation.
Example:
var jio = jIO.createJIO({type: "memory"});
IndexedDB
| parameter |
required? |
type |
description |
|---|
type |
yes |
string |
name of the storage type (here: “indexeddb”) |
database |
yes |
string |
name of the database. |
Example:
{
"type": "indexeddb",
"database": "mydb"
}
WebSQL
| parameter |
required? |
type |
description |
|---|
type |
yes |
string |
name of the storage type (here: “websql”) |
database |
yes |
string |
name of the database. |
Example:
{
"type": "websql",
"database": "mydb"
}
DavStorage
| parameter |
required? |
type |
description |
|---|
type |
yes |
string |
name of the storage type (here: “dav”) |
url |
yes |
string |
url of your webdav server |
basic_login |
no |
string |
login and password of your dav, base64 encoded like this:
btoa(username + ":" + password)
|
with_credentials |
no |
boolean |
true: send domain cookie
false: do not send domain cookie
default to false.
|
Example:
// No authentication
{
"type": "dav",
"url": url
}
// Basic authentication
{
"type": "dav",
"url": url,
"basic_login": btoa(username + ":" + password)
}
// Digest authentication is not implemented
Be careful: The generated description never contains a readable password, but
for basic authentication, the password is just base64 encoded.
Dropbox
| parameter |
required? |
type |
description |
|---|
type |
yes |
string |
name of the storage type (here: “dropbox”) |
access_token |
yes |
string |
access token for your account.
See specific documentation on how to retreive it. |
root |
no |
string |
“dropbox” for full access to account files,
“sandbox” for app limited file access.
default to “dropbox”.
|
Example:
{
"type": "dropbox",
"access_token": "sample_token"
"root": "dropbox"
}
Google Drive
| parameter |
required? |
type |
description |
|---|
type |
yes |
string |
name of the storage type (here: “gdrive”) |
access_token |
yes |
string |
access token for your account.
See specific documentation on how to retreive it. |
trashing |
no |
boolean |
true: sends files to the trash bin when doing a “remove”
false: deletes permanently files when doing a “remove”
default to true.
|
Example:
{
"type": "gdrive",
"access_token": "sample_token"
"trashing": true
}
ERP5Storage
| parameter |
required? |
type |
description |
|---|
type |
yes |
string |
name of the storage type (here: “erp5”) |
url |
yes |
string |
url of your erp5 account. |
default_view_reference |
no |
string |
reference of the action used
for the delivering of the document
|
Example:
{
"type": "erp5",
"url": erp5_url
}
Handlers
Zipstorage
This handler compresses and decompresses files to reduce network and storage usage.
Usage:
{
"type": "zip",
"sub_storage": <your storage>
}
ShaStorage
This handler provides a post method that creates a document that has for name the SHA-1 hash of his parameters.
{
"type": "sha",
"sub_storage": <your storage>
}
UUIDStorage
This handler provides a post method to create a document that has a unique ID for name.
{
"type": "uuid",
"sub_storage": <your storage>
}
QueryStorage
This handler provides an allDocs method with queries support to the substorage.
{
"type": "query",
"sub_storage": <your storage>
}
CryptStorage
This handler encrypts and decrypts attachments before storing them.
You need to generate a Crypto key at the JSON format to use the handler.
Usage:
var key,
jsonKey,
jio;
//creation of an encryption/decryption key.
crypto.subtle.generateKey({name: "AES-GCM",length: 256},
(true), ["encrypt", "decrypt"])
.then(function(res){key = res;});
window.crypto.subtle.exportKey("jwk", key)
.then(function(res){jsonKey = res})
//creation of the storage
jio = jIO.createJIO({
{
"type": "crypt",
"key": json_key
"sub_storage": <your storage>
}
UnionStorage
This handler takes in argument an array of storages.
When using a method, UnionStorage tries it on the first storage of the array,
and, in case of failure, tries with the next storage,
and repeats the operation until success, or end of storage’s array.
{
"type": "union",
"storage_list": [
sub_storage_description_1,
sub_storage_description_2,
sub_storage_description_X
]
}
FileSystemBridgeStorage
This handler adds an abstraction level on top of the webDav Jio storage,
ensuring each document has only one attachment, and limiting the storage to one repertory.
{
"type": "drivetojiomapping",
"sub_storage": <your dav storage>
}
Document Storage
This handler creates a storage from a document in a storage,
by filling his attachments with a new jIO storage.
| parameter |
required? |
type |
description |
|---|
type |
yes |
string |
name of the storage type (here: “document”) |
document_id |
no |
string |
id of the document to use. |
repair_attachment |
no |
boolean |
verify if the document is in good state. (default to false) |
Replicate Storage
Replicate Storage synchronizes documents between a local and a remote storage.
| parameter |
required? |
type |
description |
|---|
type |
yes |
string |
name of the storage type (here: “replicate”) |
local_sub_storage |
yes |
object |
local sub_storage description. |
remote_sub_storage |
yes |
object |
remote sub_storage description. |
query_options |
no |
object |
query object to limit the synchronisation to specific files. |
use_remote_post |
no |
boolean |
true: at file modification, modifies the local file id.
false: at file modification, modifies the remote file id.
default to false.
|
conflict_handling |
no |
number |
0: no conflict resolution (throws error)
1: keep the local state.
2: keep the remote state.
3: keep both states (no signature update)
default to 0.
|
check_local_modification |
no |
boolean |
synchronise when local files are modified. |
check_local_creation |
no |
boolean |
synchronise when local files are created. |
check_local_deletion |
no |
boolean |
synchronise when local files are deleted. |
check_remote_modification |
no |
boolean |
synchronise when remote files are modified. |
check_remote_creation |
no |
boolean |
synchronise when local files are created. |
check_remote_deletion |
no |
boolean |
synchronise when local files are deleted. |
synchronisation parameters are set by default to true.
{
type: 'replicate',
local_sub_storage: { 'type': 'local'}
remote_sub_storage: {
'type': 'dav',
'url': 'http://mydav.com',
'basic_login': 'aGFwcHkgZWFzdGVy'
}
use_remote_post: false,
conflict_handling : 2,
check_local_creation: false,
check_remote_deletion: false
}
jIO Query
What are Queries?
In jIO, a query can ask a storage server to select, filter, sort, or limit a
document list before sending it back. If the server is not able to do so, the
jio query tool can do the filtering by itself on the client. Only the
.allDocs() method can use jio queries.
A query can either be a string (using a specific language useful for writing
queries), or it can be a tree of objects (useful to browse queries). To handle
queries, jIO uses a parsed grammar file which is compiled using JSCC.
Why use JIO Queries?
JIO queries can be used like database queries, for tasks such as:
- search a specific document
- sort a list of documents in a certain order
- avoid retrieving a list of ten thousand documents
- limit the list to show only N documents per page
For some storages (like localStorage), jio queries can be a powerful tool to
query accessible documents. When querying documents on a distant storage, some
server-side logic should be run to avoid returning too many documents to the
client. If distant storages are static, an alternative would be to use an
indexStorage with appropriate indices as jio queries will always try to run the
query on the index before querying documents itself.
How to use Queries with jIO?
Queries can be triggered by including the option named query in the .allDocs() method call.
Example:
var options = {};
// search text query
options.query = '(creator:"John Doe") AND (format:"pdf")';
// OR query tree
options.query = {
type: 'complex',
operator: 'AND',
query_list: [{
type: 'simple',
key: 'creator',
value: 'John Doe'
}, {
type: 'simple',
key: 'format',
value: 'pdf'
}]
};
// FULL example using filtering criteria
options = {
query: '(creator:"% Doe") AND (format:"pdf")',
limit: [0, 100],
sort_on: [
['last_modified', 'descending'],
['creation_date', 'descending']
],
select_list: ['title']
};
// execution
jio_instance.allDocs(options, callback);
How to use Queries outside jIO?
Refer to the JIO Query sample page
for how to use these methods, in and outside jIO. The module provides:
jIO: {
QueryFactory: { [Function: QueryFactory] create: [Function] },
Query: { [Function: Query],
parseStringToObject: [Function],
stringEscapeRegexpCharacters: [Function],
select: [Function],
sortOn: [Function],
limit: [Function],
searchTextToRegExp: [Function],
}
SimpleQuery: {
[Function: SimpleQuery] super_: [Function: Query]
},
ComplexQuery: {
[Function: ComplexQuery] super_: [Function: Query]
}
}
(Reference API coming soon.)
Basic example:
// object list (generated from documents in storage or index)
var object_list = [
{"title": "Document number 1", "creator": "John Doe"},
{"title": "Document number 2", "creator": "James Bond"}
];
// the query to run
var query = 'title: "Document number 1"';
// running the query
var result = jIO.QueryFactory.create(query).exec(object_list);
// console.log(result);
// [ { "title": "Document number 1", "creator": "John Doe"} ]
Other example:
var result = jIO.QueryFactory.create(query).exec(
object_list,
{
"select": ['title', 'year'],
"limit": [20, 20], // from 20th to 40th document
"sort_on": [['title', 'ascending'], ['year', 'descending']],
"other_keys_and_values": "are_ignored"
}
);
// this case is equal to:
var result = jIO.QueryFactory.
create(query).exec(object_list);
jIO.Query.sortOn([
['title', 'ascending'],
['year', 'descending']
], result);
jIO.Query.limit([20, 20], result);
jIO.Query.select(['title', 'year'], result);
Query in storage connectors
The query exec method must only be used if the server is not able to pre-select
documents. As mentioned before, you could use an indexStorage to maintain
indices with key information on all documents in a storage. This index file
will then be used to run queries, if all of the fields required in the query answer
are available in the index.
Matching properties
Queries select items which exactly match the value given in the query
but you can also use wildcards (%). If you don’t want to use a wildcard,
just set the operator to =.
var option = {
query: 'creator:"% Doe"' // use wildcard
};
var option = {
query: 'creator:="25%"' // don't use wildcard
};
Should default search types be defined in jIO or in user interface components?
Default search types should be defined in the application’s user interface
components because criteria like filters will be changed frequently by the
component (change limit: [0, 10] to limit: [10, 10] or sort_on: [['title',
'ascending']] to sort_on: [['creator', 'ascending']]) and each component must
have its own default properties to keep their own behavior.
Query into another type
Example, convert Query object into a human readable string:
var query = jIO.QueryFactory.
create('year: < 2000 OR title: "%a"'),
option = {
limit: [0, 10]
},
human_read = {
"": "matches ",
"<": "is lower than ",
"<=": "is lower or equal than ",
">": "is greater than ",
">=": "is greater or equal than ",
"=": "is equal to ",
"!=": "is different than "
};
query.onParseStart = function (object, option) {
object.start = "We need only the " +
option.limit[1] +
" elements from the number " +
option.limit[0] + ". ";
};
query.onParseSimpleQuery = function (object, option) {
object.parsed = object.parsed.key +
" " + human_read[object.parsed.operator || ""] +
object.parsed.value;
};
query.onParseComplexQuery = function (object, option) {
object.parsed = "I want all document where " +
object.parsed.query_list.join(
" " + object.parsed.operator.toLowerCase() + " "
) + ". ";
};
query.onParseEnd = function (object, option) {
object.parsed = object.start + object.parsed + "Thank you!";
};
console.log(query.parse(option));
// logged: "We need only the 10 elements from the number 0. I want all
// document where year is lower than 2000 or title matches %a. Thank you!"
JSON Schemas and Grammar
Below you can find schemas for constructing queries.
Search Keys
Features like case insensitive, accent-removing, full-text searches and more can be implemented
by customizing jIO’s query behavior.
Let’s start with a simple search:
var query = {
type: 'simple',
key: 'someproperty',
value: comparison_value,
operator: '='
}
Each of the .someproperty attribute in objects’ metadata is compared with
comparison_value through a function defined by the ‘=’ operator.
You can provide your own function to be used as ‘=’ operator:
var strictEqual = function (object_value, comparison_value) {
return comparison_value === object_value;
};
var query = {
type: 'simple',
key: {
read_from: 'someproperty',
equal_match: strictEqual
},
value: comparison_value
}
Inside equal_match, you can decide to interpret the wildcard character %
or just ignore it, as in this case.
If you need to convert or preprocess the values before comparison, you can provide
a conversion function:
var numberType = function (obj) {
return parseFloat('3.14');
};
var query = {
type: 'simple',
key: {
read_from: 'someproperty',
cast_to: numberType
},
value: comparison_value
}
In this case, the operator is still the default ‘=’ that works with strings.
You can combine cast_to and equal_match:
var query = {
type: 'simple',
key: {
read_from: 'someproperty',
cast_to: numberType,
equal_match: strictEqual
},
value: comparison_value
}
Now the query returns all objects for which the following is true:
strictEqual(numberType(metadata.someproperty),
numberType(comparison_value))
For a more useful example, the following function removes the accents
from any string:
var accentFold = function (s) {
var map = [
[new RegExp('[àáâãäå]', 'gi'), 'a'],
[new RegExp('æ', 'gi'), 'ae'],
[new RegExp('ç', 'gi'), 'c'],
[new RegExp('[èéêë]', 'gi'), 'e'],
[new RegExp('[ìíîï]', 'gi'), 'i'],
[new RegExp('ñ', 'gi'), 'n'],
[new RegExp('[òóôõö]', 'gi'), 'o'],
[new RegExp('œ', 'gi'), 'oe'],
[new RegExp('[ùúûü]', 'gi'), 'u'],
[new RegExp('[ýÿ]', 'gi'), 'y']
];
map.forEach(function (o) {
var rep = function (match) {
if (match.toUpperCase() === match) {
return o[1].toUpperCase();
}
return o[1];
};
s = s.replace(o[0], rep);
});
return s;
};
...
cast_to: accentFold
...
A more robust solution to manage diacritics is recommended for production
environments, with unicode normalization, like (untested):
https://github.com/walling/unorm/
Overriding operators and sorting
The advantage of providing an equal_match function is that it can work with basic types;
you can keep the values as strings or, if you use a cast_to function, it can return strings,
numbers, arrays… and that’s fine if all you need is the ‘=’ operator.
It’s also possible to customize the behavior of the other operators: <, >, !=…
To do that, the object returned by cast_to must contain a .cmp
property, that behaves like the compareFunction described in
Array.prototype.sort():
function myType (...) {
...
return {
...
'cmp': function (b) {
if (a < b) {
return -1;
}
if (a > b) {
return +1;
}
return 0;
}
};
}
...
cast_to: myType
...
If the < or > comparison makes no sense for the objects, the function should return undefined.
The .cmp() property is also used, if present, by the sorting feature of queries.
Partial Date/Time match
As a real life example, consider a list of documents that have a start_task property.
The value of start_task can be an ISO 8601 string
with date and time information including fractions of a second. Which is, honestly, a bit too
much for most queries.
By using a cast_to function with custom operators, it is possible to perform queries like
“start_task > 2010-06”, or “start_task != 2011”. Partial time can be used as well, so
we can ask for projects started after noon of a given day: start_task = "2011-04-05" AND start_task > "2011-04-05 12"
The JIODate type has been implemented on top of the Moment.js library, which
has a rich API with support for multiple languages and timezones. No special support for timezones
is present (yet) in JIODate.
To use JIODate, include the jiodate.js and moment.js files in your
application, then set cast_to = jiodate.JIODate.
Key Schemas
Instead of providing the key object for each attribute you want to filter,
you can group all of them in a schema object for reuse:
var key_schema = {
key_set: {
date_day: {
read_from: 'date',
cast_to: 'dateType',
equal_match: 'sameDay'
},
date_month: {
read_from: 'date',
cast_to: 'dateType',
equal_match: 'sameMonth'
}
},
cast_lookup: {
dateType: function (str) {
return new Date(str);
}
},
match_lookup: {
sameDay: function (a, b) {
return (
(a.getFullYear() === b.getFullYear()) &&
(a.getMonth() === b.getMonth()) &&
(a.getDate() === b.getDate())
);
},
sameMonth: function (a, b) {
return (
(a.getFullYear() === b.getFullYear()) &&
(a.getMonth() === b.getMonth())
);
}
}
}
With this schema, we have created two ‘virtual’ metadata attributes,
date_day and date_month. When queried, they match values that
happen to be in the same day, ignoring the time, or the same month, ignoring
both time and day.
A key_schema object can have three properties:
key_set - required.cast_lookup - optional, an object of the form {name: function} that is
used if cast_to is a string. If cast_lookup is not provided,
then cast_to must be a function.match_lookup - optional, an object of the form {name: function} that is
used if equal_match is a string. If match_lookup is not provided,
then equal_match must be a function.
Using a schema
A schema can be used:
- In a query constructor. The same schema will be applied to all the sub-queries:
jIO.QueryFactory.create({...}, key_schema).exec(...);
- In the
jIO.createJIO() method. The same schema will be used
by all the queries created with the .allDocs() method:
var jio = jIO.createJIO({
type: 'local',
username: '...',
application_name: '...',
key_schema: key_schema
});
JavaScript Style Guide
This document defines JavaScript style conventions, which are split into essential, coding and naming conventions.
Essential Conventions
Essential conventions include generic patterns that you should adhere to in order to write readable, consistent and maintainable code.
Minimizing Globals
Variable declarations should always be done using var to not declare them as
global variables. This avoids conflicts from using a variable name across
different functions as well as conflicts with global variables declared by third
party plugins.
Good Example
function sum(x, y) {
var result = x + y;
return result;
}
Bad Example
function sum(x, y) {
// missing var declaration, implied global
result = x + y;
return result;
}
Using JSLint
JSLint is a quality tool that inspects code and warns
about potential problems. It can be used online and can also be integrated
into several development environments, so errors can be highlighted while
writing code.
Before validating your code in JSLint, you should use a code
beautifier to fix basic syntax errors (like indentation) automatically. There
are a number of beautifiers available online. The following ones seem to work best:
In this project, JavaScript sources have to begin with the header:
/*jslint indent: 2, maxlen: 80, nomen: true */
which means it uses two spaces indentation, 80
maximum characters per line and allows variable names starting with ‘_’.
Other JSLint options can be added in sub functions if necessary.
Some allowed options are:
ass: true if assignment should be allowed outside of statement position.bitwise: true if bitwise operators should be allowed.continue: true if the continue statement should be allowed.newcap: true if Initial Caps with constructor function is optional.regexp: true if . and [^...] should be allowed in RegExp literals. They match more material than might be expected, allowing attackers to confuse applications. These forms should not be used when validating in secure applications.unparam: true if warnings should be silenced for unused parameters.
Coding Conventions
Coding conventions include generic patterns that ensure the written code is consistently formatted.
Using two-space indentation
Tabs and 2-space indentation are being used equally. Since a lot of errors on
JSLint often result from mixed use of space and tab, using 2 spaces throughout
prevents these errors up front.
Good Example
function outer(a, b) {
var c = 1,
d = 2,
inner;
if (a > b) {
inner = function () {
return {
"r": c - d
};
};
} else {
inner = function () {
return {
"r": c + d
};
};
}
return inner;
}
Bad Example
function outer(a, b) {
var c = 1,
d = 2,
inner;
if (a > b) {
inner = function () {
return {
r: c - d
}}}};
Using shorthand for conditional statements
An alternative for using braces is the shorthand notation for conditional
statements. When using multiple conditions, the conditional statement can be
split on multiple lines.
Good Example
// single line
var results = test === true ? alert(1) : alert(2);
// multiple lines
var results = (test === true && number === undefined ?
alert(1) : alert(2));
var results = (test === true ?
alert(1) : number === undefined ?
alert(2) : alert(3));
Bad Example
// multiple conditions
var results = (test === true && number === undefined) ?
alert(1) :
alert(2);
Opening Brace Location
Always put the opening brace on the same line as the previous statement.
Bad Example
function func()
{
return
{
"name": "Batman"
};
}
Good Example
function func() {
return {
"name": "Batman"
};
}
Closing Brace Location
The closing brace should be on the same indent level as the original function call.
Bad Example
function func() {
return {
"name": "Batman"
};
}
Good Example
function func() {
return {
"name": "Batman"
};
}
Variable Declaration Location
Every variables should be declared at the top of its function.
Bad Example
function first() {
var a = 1, b = 2,
c, d;
// ...
}
function second() {
var a = 1, b = 2, c;
var d;
// ...
}
Good Example
function third() {
var a = 1, b = 2, c, d;
// ...
}
function fourth() {
var a = 1,
b = 2,
c,
d;
// ...
}
Function Declaration Location
Non anonymous functions should be declared before use and before every statements.
Bad Example
if (...) {
return {
"namedFunction": function namedFunction() { ... }
};
}
// or
if (...) {
function namedFunction() { ... }
return {
"namedFunction": namedFunction
};
}
Good Example
function namedFunction() { ... }
if (...) {
return {
"namedFunction": namedFunction
};
}
Anonymous Function Location
Execept if you want to keep your function without name, anonymous functions must
not be declared in the same place as the variables.
Bad Example
function first() {
var a = 1, b = 2, func = function () {
return a;
};
// ...
}
Good Example
function second() {
var a = 1, b = 2;
function func() {
return a;
};
// ...
}
You can assign a variable to an anonymous function inside non-loop statements.
Bad Example
function third() {
var a = 1, b = 2, func;
for (...) {
b.forEach(function () { ... });
}
// ...
}
Good Example
function fourth() {
var a = 1, b = 2, func;
if (...) {
func = function () { ... };
} else {
func = function () { ... };
}
// ...
}
function fifth() {
var a = [], b = [];
function func() { ... }
for (...) {
b.forEach(func);
}
// ...
}
Naming Conventions
Naming conventions include generic patterns for setting names and identifiers throughout a script.
Constructors
Constructor functions (called with the new statement) should always start with a capital letter:
// bad example
var test = new application();
// good example
var test = new Application();
Methods/Functions
A method/function should always start with a small letter.
// bad example
function MyFunction() {...}
// good example
function myFunction() {...}
TitleCase, camelCase
Follow the camel case convention, typing the words in lower-case, only capitalizing the first letter in each word.
// Good example constructor = TitleCase
var test = new PrototypeApplication();
// Bad example constructor
var test = new PROTOTYPEAPPLICATION();
// Good example functions/methods = camelCase
myFunction();
calculateArea();
// Bad example functions/methods
MyFunction();
CalculateArea();
Variables
Variable names with multiple words should always use an underscore between them.
// bad example
var deliveryNote = 1;
// good example
var delivery_note = 1;
Confusing variable names should end with the variable type.
// implicit type
var my_callback = doSomething();
var Person = require("./person");
// confusing names + var type
var do_something_function = doSomething.bind(context);
var value_list = getObjectOrArray();
// value_list can be an object which can be cast into an array
To use camelCase, when sometimes it is not possible to declare a function
directly, the function variable name should match some pattern which shows
that it is a function.
// good example
var doSomethingFunction = function () { ... };
// or
var tool = {"doSomething": function () { ... }};
// bad example
var doSomething = function () { ... };
Element Classes and IDs
JavaScript can access elements by their ID attribute and class names. When
assigning IDs and class names with multiple words, these should also be
separated by an underscore (same as variables).
Example
// bad example
test.setAttribute("id", "uniqueIdentifier");
// good example
test.setAttribute("id", "unique_identifier");
Discuss - checked with jQuery UI/jQuery Mobile, they don’t use written name conventions, only
- events names should fit their purpose (pageChange for changing a page)
- element classes use “-” like in ui-shadow
- “ui” should not be used by third party developers
- variables and events use lower camel-case like pageChange and activePage
Underscore Private Methods
Private methods should use a leading underscore to separate them from public methods (although this does not technically make a method private).
Good Example
var person = {
"getName": function () {
return this._getFirst() + " " + this._getLast();
},
"_getFirst": function () {
// ...
},
"_getLast": function () {
// ...
}
};
Bad Example
var person = {
"getName": function () {
return this.getFirst() + " " + this.getLast();
},
// private function
"getFirst": function () {
// ...
}
};
No Abbreviations
Abbreviations should not be used to avoid confusion.
Good Example
// delivery note
var delivery_note = 1;
Bad Example
// delivery note
var del_note = 1;
No Plurals
Plurals should not be used as variable names.
// good example
var delivery_note_list = ["one", "two"];
// bad example
var delivery_notes = ["one", "two"];
Documentation
You can use YUIDoc and its custom comment
tags together with Node.js to generate the documentation from the script file
itself. Comments should look like this:
Good Example
/**
* Reverse a string
*
* @param {String} input_string String to reverse
* @return {String} The reversed string
*/
function reverse(input_string) {
// ...
return output_string;
};
Bad Example
function reverse(input_string) {
// ...
return output_string;
};
Additional Readings
Resources, additional reading materials and links:
