WIP
parent
82af54b214
commit
ba6ff51b2f
@ -0,0 +1,30 @@
|
||||
'use strict';
|
||||
|
||||
module.exports.up = function(knex, Promise) {
|
||||
return Promise.try(() => {
|
||||
return knex.schema.createTable("users", (table) => {
|
||||
table.bigIncrements("id").primary();
|
||||
table.text("username").notNull();
|
||||
table.text("password_hash");
|
||||
table.enum("type", ["user", "guest"]).notNull();
|
||||
});
|
||||
}).then(() => {
|
||||
return knex.schema.createTable("devices", (table) => {
|
||||
table.bigIncrements("id").primary();
|
||||
table.integer("user_id").notNull().references("users.id");
|
||||
table.text("name");
|
||||
table.text("device_id").notNull();
|
||||
table.text("token").notNull();
|
||||
|
||||
table.unique(["user_id", "device_id"]);
|
||||
});
|
||||
});
|
||||
};
|
||||
|
||||
module.exports.down = function(knex, Promise) {
|
||||
return Promise.try(() => {
|
||||
return knex.schema.dropTable("devices");
|
||||
}).then(() => {
|
||||
return knex.schema.dropTable("users");
|
||||
});
|
||||
};
|
||||
@ -0,0 +1,62 @@
|
||||
QUESTIONS:
|
||||
- What are allowable characters for a device ID?
|
||||
https://github.com/matrix-org/matrix-doc/issues/1257
|
||||
|
||||
----
|
||||
|
||||
The txn_id in a token authentication request is meant to be tied permanently to the (single-use) token by the server, *after* the first request from the client that includes the txn_id. It functions as a nonce that other clients would not be able to guess, essentially locking the token to a specific client. Ref https://github.com/matrix-org/matrix-doc/pull/69
|
||||
|
||||
----
|
||||
|
||||
Error metadata:
|
||||
TooManyRequests: { retry_after_ms: 2000 }
|
||||
|
||||
----
|
||||
|
||||
Deprecated features to maybe support later:
|
||||
-
|
||||
|
||||
----
|
||||
|
||||
Skipped, todo later:
|
||||
|
||||
GET /_matrix/static/client/login/
|
||||
https://matrix.org/docs/spec/client_server/r0.4.0.html#id216
|
||||
This returns an HTML and JavaScript page which can perform the entire login process. The page will attempt to call the JavaScript function window.onLogin when login has been successfully completed.
|
||||
|
||||
-----
|
||||
|
||||
GUEST ACCOUNTS
|
||||
|
||||
https://matrix.org/docs/spec/client_server/r0.4.0.html#id520
|
||||
|
||||
The following API endpoints are allowed to be accessed by guest accounts for retrieving events:
|
||||
|
||||
GET /rooms/:room_id/state
|
||||
GET /rooms/:room_id/context/:event_id
|
||||
GET /rooms/:room_id/event/:event_id
|
||||
GET /rooms/:room_id/state/:event_type/:state_key
|
||||
GET /rooms/:room_id/messages
|
||||
GET /rooms/:room_id/initialSync
|
||||
GET /sync
|
||||
GET /events as used for room previews.
|
||||
|
||||
The following API endpoints are allowed to be accessed by guest accounts for sending events:
|
||||
|
||||
POST /rooms/:room_id/join
|
||||
POST /rooms/:room_id/leave
|
||||
PUT /rooms/:room_id/send/m.room.message/:txn_id
|
||||
PUT /sendToDevice/{eventType}/{txnId}
|
||||
|
||||
The following API endpoints are allowed to be accessed by guest accounts for their own account maintenance:
|
||||
|
||||
PUT /profile/:user_id/displayname
|
||||
GET /devices
|
||||
GET /devices/{deviceId}
|
||||
PUT /devices/{deviceId}
|
||||
|
||||
The following API endpoints are allowed to be accessed by guest accounts for end-to-end encryption:
|
||||
|
||||
POST /keys/upload
|
||||
POST /keys/query
|
||||
POST /keys/claim
|
||||
@ -0,0 +1,16 @@
|
||||
"use strict";
|
||||
|
||||
const errors = require("../errors");
|
||||
|
||||
module.exports = function decodeAccessToken(encodedAccessToken) {
|
||||
if (encodedAccessToken.includes(":")) {
|
||||
let [encodedDeviceId, token] = encodedAccessToken.split(":");
|
||||
|
||||
return {
|
||||
deviceId: Buffer.from(encodedDeviceId, "base64").toString(),
|
||||
token: token
|
||||
};
|
||||
} else {
|
||||
throw new errors.InvalidAccessToken("Invalid access token provided");
|
||||
}
|
||||
};
|
||||
@ -0,0 +1,9 @@
|
||||
"use strict";
|
||||
|
||||
module.exports = function encodeAccessToken({ deviceId, token }) {
|
||||
if (deviceId == null || token == null) {
|
||||
throw new Error("Device ID and token are required");
|
||||
} else {
|
||||
return `${Buffer.from(deviceId).toString("base64")}:${token}`;
|
||||
}
|
||||
};
|
||||
@ -0,0 +1,7 @@
|
||||
"use strict";
|
||||
|
||||
module.exports = function ({ db }) {
|
||||
return function passwordAuthenticator(data) {
|
||||
|
||||
}
|
||||
};
|
||||
@ -0,0 +1,7 @@
|
||||
"use strict";
|
||||
|
||||
const PhoneNumber = require("awesome-phonenumber");
|
||||
|
||||
module.exports = function canonicalizePhoneNumber(isoRegionCode, phoneNumber) {
|
||||
return PhoneNumber(phoneNumber, isoRegionCode).getNumber("e164").replace(/^\+/, "");
|
||||
};
|
||||
@ -0,0 +1,17 @@
|
||||
"use strict";
|
||||
|
||||
/* FIXME: Complete, maybe */
|
||||
|
||||
const Promise = require("bluebird");
|
||||
|
||||
module.exports = function atLeastOne(method) {
|
||||
return function methodWrapper(...args) {
|
||||
return Promise.try(() => {
|
||||
return method(...args);
|
||||
}).then((result) => {
|
||||
if (Array.isArray(result)) {
|
||||
|
||||
}
|
||||
})
|
||||
}
|
||||
};
|
||||
@ -0,0 +1,23 @@
|
||||
"use strict";
|
||||
|
||||
const Promise = require("bluebird");
|
||||
const mapObj = require("map-obj");
|
||||
const databaseError = require("database-error");
|
||||
|
||||
function wrapMethod(value) {
|
||||
if (typeof value === "function") {
|
||||
return function wrappedDatabaseMethod(...args) {
|
||||
return Promise.try(() => {
|
||||
return value(...args);
|
||||
}).catch(databaseError.rethrow);
|
||||
};
|
||||
} else {
|
||||
return value;
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = function createDatabaseModule(methods) {
|
||||
return mapObj(methods, (key, value) => {
|
||||
return [key, wrapMethod(value)];
|
||||
});
|
||||
};
|
||||
@ -0,0 +1,39 @@
|
||||
"use strict";
|
||||
|
||||
const Promise = require("bluebird");
|
||||
const scryptForHumans = require("scrypt-for-humans");
|
||||
|
||||
const errors = require("../errors");
|
||||
const extractLocalPart = require("../extract-local-part");
|
||||
const createDatabaseModule = require("../db-module");
|
||||
|
||||
module.exports = function ({ knex }) {
|
||||
return createDatabaseModule({
|
||||
create: function ({ username, password, type }, tx = knex) {
|
||||
return Promise.try(() => {
|
||||
if (password != null) {
|
||||
return scryptForHumans.hash(password);
|
||||
}
|
||||
}).then((hash) => {
|
||||
return tx("users").insert({
|
||||
username: username,
|
||||
password_hash: hash,
|
||||
type: type
|
||||
}).returning("*");
|
||||
});
|
||||
},
|
||||
byUsername: function ({ username }, tx = knex) {
|
||||
return Promise.try(() => {
|
||||
/* TODO: Validate that, if a fully-qualified ID is passed in, it's for the correct homeserver? */
|
||||
return tx("users").first().where({ username: extractLocalPart(username) });
|
||||
}).then((user) => {
|
||||
if (user != null) {
|
||||
return user;
|
||||
} else {
|
||||
throw new errors.InvalidUsername("No such user exists");
|
||||
/* FIXME: Map to 403 error in login route */
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
};
|
||||
@ -1,7 +1,91 @@
|
||||
"use strict";
|
||||
|
||||
module.exports = function ({db}) {
|
||||
return {
|
||||
const Promise = require("bluebird");
|
||||
const crypto = require("crypto");
|
||||
const nanoid = require("nanoid");
|
||||
const defaultValue = require("default-value");
|
||||
const databaseError = require("database-error");
|
||||
|
||||
};
|
||||
const errors = require("../errors");
|
||||
const createDatabaseModule = require("../db-module");
|
||||
|
||||
function tokensMatch(a, b) {
|
||||
return crypto.timingSafeEqual(Buffer.from(a), Buffer.from(b));
|
||||
}
|
||||
|
||||
module.exports = function ({ knex }) {
|
||||
return createDatabaseModule({
|
||||
create: function ({ name, deviceId, userId, token }, tx = knex) {
|
||||
return Promise.try(() => {
|
||||
let token_ = defaultValue(token, nanoid());
|
||||
let deviceId_ = defaultValue(deviceId, nanoid());
|
||||
|
||||
return tx("devices").insert({
|
||||
device_id: deviceId_,
|
||||
user_id: userId,
|
||||
name: name,
|
||||
token: token_,
|
||||
}).returning("*");
|
||||
}).then((results) => {
|
||||
return results[0];
|
||||
});
|
||||
},
|
||||
byDeviceId: function ({ deviceId }, tx = knex) {
|
||||
return Promise.try(() => {
|
||||
return tx("devices").first().where({ device_id: deviceId });
|
||||
}).then((result) => {
|
||||
if (result != null) {
|
||||
return result;
|
||||
} else {
|
||||
throw new errors.NotFound("The specified device ID does not exist");
|
||||
}
|
||||
});
|
||||
},
|
||||
byDeviceIdAndToken: function ({ deviceId, token }, _tx = knex) {
|
||||
/* NOTE: This is intentionally a separate method as opposed to conditional logic in byDeviceId, to prevent cases where a bug results in a user-specified token not being passed in - which would fail unsafely by allowing any token, if conditional logic were used. */
|
||||
return Promise.try(() => {
|
||||
if (token != null) {
|
||||
return this.byDeviceId({ deviceId });
|
||||
} else {
|
||||
throw new errors.MissingAccessToken("No access token was specified");
|
||||
}
|
||||
}).then((device) => {
|
||||
if (tokensMatch(token, device.token)) {
|
||||
return device;
|
||||
} else {
|
||||
throw new errors.InvalidAccessToken("Specified token was invalid");
|
||||
}
|
||||
});
|
||||
},
|
||||
updateToken: function ({ userId, deviceId, token }, tx = knex) {
|
||||
return Promise.try(() => {
|
||||
return tx("devices")
|
||||
.update({ token: token })
|
||||
.where({
|
||||
device_id: deviceId,
|
||||
user_id: userId
|
||||
})
|
||||
.returning("*");
|
||||
}).then((results) => {
|
||||
if (results.length > 0) {
|
||||
return results[0];
|
||||
} else {
|
||||
throw new errors.NotFound("Specified Device ID does not exist");
|
||||
}
|
||||
});
|
||||
},
|
||||
createDeviceSession: function ({ name, deviceId, userId }, _tx = knex) {
|
||||
return Promise.try(() => {
|
||||
let token = nanoid();
|
||||
|
||||
return Promise.try(() => {
|
||||
return this.create({ name, deviceId, userId, token });
|
||||
}).catch({ name: "UniqueConstraintViolationError", table: "devices", column: "device_id" }, (_error) => {
|
||||
return this.updateToken({ userId, deviceId, token });
|
||||
}).then((device) => {
|
||||
/* FIXME */
|
||||
});
|
||||
});
|
||||
}
|
||||
});
|
||||
};
|
||||
@ -0,0 +1,9 @@
|
||||
"use strict";
|
||||
|
||||
module.exports = function extractLocalPart(id) {
|
||||
if (id.includes(":")) {
|
||||
return id.split(":")[0];
|
||||
} else {
|
||||
return id;
|
||||
}
|
||||
};
|
||||
@ -0,0 +1,15 @@
|
||||
"use strict";
|
||||
|
||||
module.exports = function matchValue(value, arms) {
|
||||
for (let [candidateValue, arm] of Object.entries(arms)) {
|
||||
if (candidateValue !== "_" && value === candidateValue) {
|
||||
return arm();
|
||||
}
|
||||
}
|
||||
|
||||
if (arms._ != null) {
|
||||
return arms._();
|
||||
} else {
|
||||
throw new Error("No matching arm found");
|
||||
}
|
||||
};
|
||||
@ -0,0 +1,20 @@
|
||||
"use strict";
|
||||
|
||||
function applyNormalizations(payload, normalizations) {
|
||||
return normalizations.reduce((current, normalization) => {
|
||||
let changes = normalization(current);
|
||||
|
||||
if (changes == null) {
|
||||
return current;
|
||||
} else {
|
||||
return Object.assign(current, changes);
|
||||
}
|
||||
}, Object.assign({}, payload));
|
||||
}
|
||||
|
||||
module.exports = function createNormalizationMiddleware(normalizations) {
|
||||
return function normalizePayload(req, _res, next) {
|
||||
req.body = applyNormalizations(req.body, normalizations);
|
||||
next();
|
||||
}
|
||||
};
|
||||
@ -1,11 +1,14 @@
|
||||
"use strict";
|
||||
|
||||
const errors = require("../errors");
|
||||
const Promise = require("bluebird");
|
||||
|
||||
module.exports = function requireAccessToken(req, res, next) {
|
||||
if (req.matrixAccessToken == null) {
|
||||
throw new errors.UnauthorizedError("An access token is required, but none was provided", {
|
||||
errorCode: "M_MISSING_TOKEN"
|
||||
module.exports = function ({ db }) {
|
||||
return function requireAccessToken(req, _res, next) {
|
||||
return Promise.try(() => {
|
||||
return db.devices.byToken(req.matrixAccessToken);
|
||||
}).then((device) => {
|
||||
req.device = device;
|
||||
next();
|
||||
});
|
||||
}
|
||||
};
|
||||
};
|
||||
};
|
||||
|
||||
@ -0,0 +1,36 @@
|
||||
"use strict";
|
||||
|
||||
// const Joi = require("@hapi/joi");
|
||||
|
||||
const errors = require("../errors");
|
||||
|
||||
const {validate, ValidationError} = require("../validate");
|
||||
|
||||
module.exports = function createPayloadValidator(validator) {
|
||||
return function validatePayload(req, _res, next) {
|
||||
try {
|
||||
validate(validator, req.body);
|
||||
} catch (error) {
|
||||
if (error instanceof ValidationError) {
|
||||
console.log(require("util").inspect(error, {colors: true, depth: null}));
|
||||
throw new errors.MissingParameter("Something in the validation was wrong");
|
||||
} else {
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
next();
|
||||
|
||||
|
||||
// let result = Joi.validate(req.body, schema);
|
||||
|
||||
// if (result.error != null) {
|
||||
// /* FIXME: Actually produce meaningful output based on the Joi output */
|
||||
// console.log(require("util").inspect(result.error, {colors: true, depth: null}));
|
||||
|
||||
// throw new errors.MissingParameter("Something in the validation was wrong");
|
||||
// } else {
|
||||
// next();
|
||||
// }
|
||||
}
|
||||
};
|
||||
@ -0,0 +1,14 @@
|
||||
"use strict";
|
||||
|
||||
const nanoidGenerate = require("nanoid/generate");
|
||||
const uppercaseAlphabet = require("nanoid-dictionary/uppercase");
|
||||
|
||||
module.exports = function processDeviceId(deviceId) {
|
||||
/* TODO: Add validation here, once it becomes clear what the formatting requirements for a Device ID are */
|
||||
|
||||
if (deviceId != null && deviceId.length > 0) {
|
||||
return deviceId;
|
||||
} else {
|
||||
return nanoidGenerate(uppercaseAlphabet, 16);
|
||||
}
|
||||
};
|
||||
@ -0,0 +1,27 @@
|
||||
"use strict";
|
||||
|
||||
const expressPromiseRouter = require("express-promise-router");
|
||||
|
||||
module.exports = function(state) {
|
||||
let {db} = state;
|
||||
let router = expressPromiseRouter();
|
||||
|
||||
router.get("/r0/account/3pid", (req, res) => {
|
||||
// https://matrix.org/docs/spec/client_server/r0.4.0.html#get-matrix-client-r0-account-3pid
|
||||
// Gets a list of the third party identifiers that the homeserver has associated with the user's account. This is not the same as the list of third party identifiers bound to the user's Matrix ID in identity servers.
|
||||
});
|
||||
|
||||
router.post("/r0/account/3pid", (req, res) => {
|
||||
// https://matrix.org/docs/spec/client_server/r0.4.0.html#post-matrix-client-r0-account-3pid
|
||||
// Adds contact information to the user's account.
|
||||
});
|
||||
|
||||
router.post("/r0/account/3pid/delete", (req, res) => {
|
||||
// https://matrix.org/docs/spec/client_server/r0.4.0.html#post-matrix-client-r0-account-3pid-delete
|
||||
// Removes a third party identifier from the user's account. This might not cause an unbind of the identifier from the identity server.
|
||||
});
|
||||
|
||||
// MARKER: https://matrix.org/docs/spec/client_server/r0.4.0.html#id231
|
||||
|
||||
return router;
|
||||
}
|
||||
@ -0,0 +1,221 @@
|
||||
"use strict";
|
||||
|
||||
const Promise = require("bluebird");
|
||||
const expressPromiseRouter = require("express-promise-router");
|
||||
const scryptForHumans = require("scrypt-for-humans");
|
||||
|
||||
const errors = require("../../errors");
|
||||
const normalize = require("../../middlewares/normalize-payload");
|
||||
const validate = require("../../middlewares/validate-payload");
|
||||
const processDeviceId = require("../../process-device-id");
|
||||
const matchValue = require("../../match-value");
|
||||
const canonicalizePhoneNumber = require("../../canonicalize-phone-number");
|
||||
|
||||
function normalizeIdentifier(payload) {
|
||||
if (payload.identifier != null) {
|
||||
/* Never overwrite the `identifier` key if it already exists */
|
||||
return null;
|
||||
} else if (payload.user != null) {
|
||||
return {
|
||||
identifier: {
|
||||
type: "m.id.user",
|
||||
user: payload.user
|
||||
}
|
||||
};
|
||||
} else if (payload.address != null) {
|
||||
return {
|
||||
identifier: {
|
||||
type: "m.id.thirdparty",
|
||||
medium: payload.medium,
|
||||
address: payload.address
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
function normalizePhoneNumber(payload) {
|
||||
if (payload.identifier != null && payload.identifier.type === "m.id.phone") {
|
||||
return {
|
||||
identifier: {
|
||||
type: "m.id.thirdparty",
|
||||
medium: "msisdn",
|
||||
address: canonicalizePhoneNumber(payload.identifier.country, payload.identifier.phone)
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
function validateUserIdentifier(userIdentifier) {
|
||||
let {assertProperties, isPresent, isString, isOneOf} = require("../../validate.js");
|
||||
|
||||
assertProperties(userIdentifier, {
|
||||
type: [ isPresent, isOneOf("m.id.user", "m.id.thirdparty", "m.id.phone") ]
|
||||
});
|
||||
|
||||
matchValue(userIdentifier.type, {
|
||||
"m.id.user": () => {
|
||||
assertProperties(userIdentifier, {
|
||||
user: [ isPresent, isString ]
|
||||
});
|
||||
},
|
||||
"m.id.thirdparty": () => {
|
||||
assertProperties(userIdentifier, {
|
||||
medium: [ isPresent, isString ],
|
||||
address: [ isPresent, isString ]
|
||||
});
|
||||
},
|
||||
"m.id.phone": () => {
|
||||
assertProperties(userIdentifier, {
|
||||
country: [ isPresent, isString ],
|
||||
phone: [ isPresent, isString ]
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
module.exports = function(state) {
|
||||
const requireAccessToken = require("../../middlewares/require-access-token")(state);
|
||||
|
||||
let {db, configuration, fullyQualifyUser} = state;
|
||||
let router = expressPromiseRouter();
|
||||
|
||||
router.get("/r0/login", (req, res) => {
|
||||
res.json({
|
||||
flows: [{ type: "m.login.password" }]
|
||||
});
|
||||
});
|
||||
|
||||
function validateLoginPayload(payload) {
|
||||
let {assertProperties, isPresent, isString, isOneOf} = require("../../validate.js");
|
||||
|
||||
assertProperties(payload, {
|
||||
type: [ isPresent, isOneOf("m.login.password", "m.login.token") ],
|
||||
device_id: [ isString ],
|
||||
initial_device_display_name: [ isString ],
|
||||
});
|
||||
|
||||
matchValue(payload.type, {
|
||||
"m.login.password": () => {
|
||||
assertProperties(payload, {
|
||||
identifier: [ isPresent, validateUserIdentifier ],
|
||||
password: [ isPresent, isString ]
|
||||
});
|
||||
},
|
||||
"m.login.token": () => {
|
||||
assertProperties(payload, {
|
||||
token: [ isPresent, isString ]
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
router.post("/r0/login", normalize([normalizeIdentifier, normalizePhoneNumber]), validate(validateLoginPayload), (req, res) => {
|
||||
// https://matrix.org/docs/spec/client_server/r0.4.0.html#get-matrix-client-r0-login
|
||||
// Authenticates the user, and issues an access token they can use to authorize themself in subsequent requests.
|
||||
|
||||
/* FIXME: Rate-limit */
|
||||
|
||||
return Promise.try(() => {
|
||||
if (req.body.identifier.type === "m.id.user") {
|
||||
return db.accounts.byUsername({
|
||||
username: req.body.identifier.user
|
||||
});
|
||||
} else if (req.body.identifier.type === "m.id.thirdparty") {
|
||||
// FIXME
|
||||
} else {
|
||||
/* NOTE: We're not handling m.id.phone here, as that's normalized into m.id.thirdparty in normalizePhoneNumber */
|
||||
throw new errors.Unreachable("Invalid identifier type");
|
||||
}
|
||||
}).then((user) => {
|
||||
let deviceId = processDeviceId(req.body.device_id);
|
||||
|
||||
return Promise.try(() => {
|
||||
if (req.body.type === "m.login.password") {
|
||||
return scryptForHumans.verifyHash(req.body.password, user.password_hash);
|
||||
} else if (req.body.type === "m.login.token") {
|
||||
// FIXME
|
||||
} else {
|
||||
throw new errors.Unreachable("Invalid login type");
|
||||
}
|
||||
}).then(() => {
|
||||
return db.devices.createDeviceSession({
|
||||
name: req.body.initial_device_display_name,
|
||||
deviceId: deviceId,
|
||||
userId: user.id
|
||||
}).then((device) => {
|
||||
res.send({
|
||||
access_token: device.token,
|
||||
user_id: fullyQualifyUser(user.username),
|
||||
home_server: configuration.hostname,
|
||||
device_id: device.deviceId
|
||||
});
|
||||
});
|
||||
});
|
||||
}).catch(errors.InvalidUsername, errors.Forbidden.chain("Invalid username specified"))
|
||||
.catch(scryptForHumans.PasswordError, errors.Forbidden.chain("Invalid password specified"));
|
||||
/* FIXME: Formatting above */
|
||||
});
|
||||
|
||||
router.post("/r0/logout", requireAccessToken, (req, res) => {
|
||||
// https://matrix.org/docs/spec/client_server/r0.4.0.html#post-matrix-client-r0-logout
|
||||
// Invalidates an existing access token, so that it can no longer be used for authorization.
|
||||
});
|
||||
|
||||
router.post("/r0/logout/all", requireAccessToken, (req, res) => {
|
||||
// https://matrix.org/docs/spec/client_server/r0.4.0.html#post-matrix-client-r0-logout-all
|
||||
// Invalidates all access tokens for a user, so that they can no longer be used for authorization. This includes the access token that made this request.
|
||||
});
|
||||
|
||||
router.post("/r0/register/available", (req, res) => {
|
||||
// https://matrix.org/docs/spec/client_server/r0.4.0.html#get-matrix-client-r0-register-available
|
||||
// Checks to see if a username is available, and valid, for the server.
|
||||
});
|
||||
|
||||
router.post("/r0/register", (req, res) => {
|
||||
// https://matrix.org/docs/spec/client_server/r0.4.0.html#post-matrix-client-r0-register
|
||||
// Register for an account on this homeserver. This API endpoint uses the User-Interactive Authentication API.
|
||||
// Optionally allows user-interactive auth
|
||||
});
|
||||
|
||||
router.post("/r0/register/:source/requestToken", (req, res) => {
|
||||
// source === "email"
|
||||
// https://matrix.org/docs/spec/client_server/r0.4.0.html#post-matrix-client-r0-register-email-requesttoken
|
||||
// Proxies the Identity Service API validate/email/requestToken, but first checks that the given email address is not already associated with an account on this homeserver. See the Identity Service API for further information.
|
||||
|
||||
// source === "msisdn"
|
||||
// https://matrix.org/docs/spec/client_server/r0.4.0.html#post-matrix-client-r0-register-msisdn-requesttoken
|
||||
// Proxies the Identity Service API validate/msisdn/requestToken, but first checks that the given phone number is not already associated with an account on this homeserver. See the Identity Service API for further information.
|
||||
|
||||
// NOTE: Unclear whether it requires authentication or not.
|
||||
});
|
||||
|
||||
router.post("/r0/account/password", (req, res) => {
|
||||
// https://matrix.org/docs/spec/client_server/r0.4.0.html#post-matrix-client-r0-account-password
|
||||
// Changes the password for an account on this homeserver.
|
||||
|
||||
// NOTE: Requires access token *or* interactive auth.
|
||||
});
|
||||
|
||||
router.post("/r0/account/password/:source/requestToken", (req, res) => {
|
||||
// source === "email"
|
||||
// https://matrix.org/docs/spec/client_server/r0.4.0.html#post-matrix-client-r0-account-password-email-requesttoken
|
||||
// Proxies the Identity Service API validate/email/requestToken, but first checks that the given email address is associated with an account on this homeserver. This API should be used to request validation tokens when authenticating for the account/password endpoint.
|
||||
|
||||
// source === "msisdn"
|
||||
// https://matrix.org/docs/spec/client_server/r0.4.0.html#post-matrix-client-r0-account-password-msisdn-requesttoken
|
||||
// Proxies the Identity Service API validate/msisdn/requestToken, but first checks that the given phone number is associated with an account on this homeserver. This API should be used to request validation tokens when authenticating for the account/password endpoint.
|
||||
|
||||
// NOTE: Unclear whether it requires authentication or not.
|
||||
});
|
||||
|
||||
router.post("/r0/account/deactivate", (req, res) => {
|
||||
// https://matrix.org/docs/spec/client_server/r0.4.0.html#post-matrix-client-r0-account-deactivate
|
||||
// Deactivate the user's account, removing all ability for the user to login again. This API endpoint uses the User-Interactive Authentication API.
|
||||
|
||||
// NOTE: Requires access token *or* interactive auth.
|
||||
});
|
||||
|
||||
// FIXME: Modularize out 'create session for device' logic for both login and register endpoints
|
||||
|
||||
return router;
|
||||
}
|
||||
@ -0,0 +1,119 @@
|
||||
"use strict";
|
||||
|
||||
const errorChain = require("error-chain");
|
||||
|
||||
let ValidationError = errorChain("ValidationError");
|
||||
|
||||
function isPresent(value) {
|
||||
if (value == null) {
|
||||
throw new ValidationError("Required value is missing", { errorType: "isPresent" });
|
||||
}
|
||||
}
|
||||
|
||||
function isString(value) {
|
||||
if (value != null && typeof value !== "string") {
|
||||
throw new ValidationError("Value is not a string", { errorType: "isString" });
|
||||
}
|
||||
}
|
||||
|
||||
function isOneOf(...acceptableValues) {
|
||||
let valueSet = new Set(acceptableValues);
|
||||
|
||||
return function (value) {
|
||||
if (value != null && !valueSet.has(value)) {
|
||||
throw new ValidationError("Value is not one of the specified acceptable values", {
|
||||
errorType: "isOneOf",
|
||||
acceptableValues: acceptableValues
|
||||
});
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/* NOTE: Extremely sketchy way of tracking validation state via a module-global object, but we can get away with this because validation is completely synchronous */
|
||||
let context;
|
||||
|
||||
function assertProperties(object, properties) {
|
||||
for (let [property, assertions] of Object.entries(properties)) {
|
||||
context.path.push(property);
|
||||
|
||||
let value = object[property];
|
||||
|
||||
try {
|
||||
for (let assertion of assertions) {
|
||||
assertion(value);
|
||||
}
|
||||
} catch (error) {
|
||||
if (error.input == null) {
|
||||
error.input = value;
|
||||
}
|
||||
|
||||
throw error;
|
||||
}
|
||||
|
||||
context.path.pop();
|
||||
}
|
||||
}
|
||||
|
||||
function arrayOf(assertions) {
|
||||
return function (value) {
|
||||
if (value != null) {
|
||||
if (!Array.isArray(value)) {
|
||||
throw new ValidationError("Value is not an array", { errorType: "arrayOf" });
|
||||
} else {
|
||||
for (let [i, item] of value.entries()) {
|
||||
context.path.push(i);
|
||||
|
||||
try {
|
||||
for (let assertion of assertions) {
|
||||
assertion(item);
|
||||
}
|
||||
} catch (error) {
|
||||
if (error.input == null) {
|
||||
error.input = value;
|
||||
}
|
||||
|
||||
throw error;
|
||||
}
|
||||
|
||||
context.path.pop();
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
function validate(validator, value) {
|
||||
context = {
|
||||
path: []
|
||||
};
|
||||
|
||||
try {
|
||||
validator(value);
|
||||
} catch (error) {
|
||||
if (error.path == null) {
|
||||
error.path = context.path;
|
||||
}
|
||||
|
||||
throw error;
|
||||
}
|
||||
|
||||
context = undefined;
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
validate, assertProperties, ValidationError,
|
||||
isPresent, isString, isOneOf, arrayOf
|
||||
};
|
||||
|
||||
// try {
|
||||
// validate(validateLoginPayload, {
|
||||
// type: 'm.login.password',
|
||||
// password: 'test',
|
||||
// identifier: { type: 'm.id.user', user: 'joepie91' },
|
||||
// initial_device_display_name: 'http://localhost:3001/index.html via Firefox on Linux',
|
||||
// user: 'joepie91',
|
||||
// arrayStuff: [ 42 ]
|
||||
// });
|
||||
// } catch (error) {
|
||||
// console.log(require("util").inspect(error, {colors: true, depth: null}));
|
||||
// }
|
||||
Loading…
Reference in New Issue