yekonga-server
Version:
Yekonga Server
343 lines (297 loc) • 13 kB
JavaScript
/*global Yekonga, serverLibrary */
// @ts-nocheck
const H = Yekonga.Helper;
const defaultConfig = {};
const fs = serverLibrary.fs;
const cors = serverLibrary.cors;
const path = serverLibrary.path;
const express = serverLibrary.express;
const ApolloServer = serverLibrary.ApolloServer;
const expressMiddleware = serverLibrary.expressMiddleware;
const ApolloServerPluginDrainHttpServer = serverLibrary.ApolloServerPluginDrainHttpServer;
const SystemDataController = require('./systemDataController');
Yekonga.GenerateIndex = async() => {
const indexedTypes = ["select", "radio", "date", "boolean"];
for (const key in Yekonga.SystemModels) {
const collection = Yekonga.SystemModels[key];
for (const field of collection.fields) {
const indexKeys = {};
if (indexedTypes.includes(field.input)) {
indexKeys[field.name] = 1;
try {
Yekonga.DB.table(collection.name).createIndex(indexKeys, {});
} catch (error) {
console.error(`collection <${collection.name}> not found`)
}
}
}
const indexKeys = {};
if (!indexKeys[collection.secondaryKey]) {
indexKeys[collection.secondaryKey] = 1;
}
try {
Yekonga.DB.table(collection.name).createIndex(indexKeys, {});
} catch (error) {
console.error(`collection <${collection.name}> not found`)
}
}
console.debug(`Database Indexes: created`);
}
class YekongaServer {
constructor(config, schema) {
this.config(config, schema);
}
config(config, schema) {
var controller = new SystemDataController(schema);
Yekonga.Schema = controller.schema;
Yekonga.SystemModels = H.getTableDataWithRelations();
this.setConfig(config);
this.init();
}
init() {
this.setDatabase();
this.setDataModel();
H.setTypeDefs();
H.setResolvers();
this.setCloudFunction();
this.setDataGroups();
this.setGraphgl();
}
setConfig(_config) {
const config = defaultConfig;
if (_config) {
for (const key in _config) {
if (_config.hasOwnProperty(key)) {
config[key] = _config[key];
}
}
}
Yekonga.Config = config;
Yekonga.AdminDB = Yekonga.DBbuilder({
type: "nedb",
tables: [
// { collection: `pages`, path: path.join(serverLibrary.__dirname, 'archives/pages.db') },
// { collection: `translator_languages`, path: path.join(serverLibrary.__dirname, 'archives/languages.db') },
// { collection: `translator_translations`, path: path.join(serverLibrary.__dirname, 'archives/translations.db') },
// { collection: `auth_permissions`, path: path.join(serverLibrary.__dirname, 'archives/permissions.db') },
],
}, null);
Yekonga.SystemDB = Yekonga.DBbuilder({
type: "nedb",
tables: [
{ collection: `relation_data` },
],
}, null);
}
setDataModel() {
const DataControl = require('./modelControl');
if (!Yekonga.Model) Yekonga.Model = {}
if (!Yekonga.DataModel) Yekonga.DataModel = {}
for (const row of Yekonga.Schema) {
const collection = row._id.collection;
const schemaInstance = new DataControl(row);
const modeClass = H.getClass(collection);
Yekonga.Model[modeClass] = schemaInstance.create();
Yekonga.DataModelInstance[modeClass] = schemaInstance;
// Yekonga.DataModel[modeClass] = Yekonga.Model[modeClass];
Object.defineProperty(Yekonga.DataModel, modeClass, {
get: function() { return Yekonga.Model[modeClass]; }
});
}
}
setGraphgl() {
Yekonga.Graphql.Handler = require('./graphql/handler');
const userCollection = Yekonga.Helper.getCollectionByName("users");
var userRoles = [];
if (userCollection && userCollection.role) {
userRoles = userCollection.role.options;
if (!Array.isArray(userRoles)) {
if (userRoles && typeof userRoles == "object") {
var _userRoles = [];
for (const key in userRoles) {
_userRoles.push(key);
}
userRoles = _userRoles;
}
}
}
for (const key of userRoles) {
Yekonga.Graphql.Resolvers.User[H.getVariable('is_' + key)] = async function(parent, params, context) {
return (parent && parent.role == key);
}
}
for (const key1 in Yekonga.Graphql.Resolvers) {
if (Yekonga.Graphql.Resolvers.hasOwnProperty(key1)) {
if (Yekonga.CloudService.Resolvers[`${key1}`]) {
Yekonga.Graphql.Resolvers[key1] = Yekonga.CloudService.Resolvers[`${key1}`];
} else {
for (const key2 in Yekonga.Graphql.Resolvers[key1]) {
if (Yekonga.Graphql.Resolvers[key1].hasOwnProperty(key2)) {
if (Yekonga.CloudService.Resolvers[`${key1}.${key2}`]) {
Yekonga.Graphql.Resolvers[key1][key2] = Yekonga.CloudService.Resolvers[`${key1}.${key2}`];
}
}
}
}
}
}
Yekonga.Graphql.apiRoute = async (app) => {
// GraphQL: Schema
const SchemaConfig = {
typeDefs: Yekonga.Graphql.typeDefs,
resolvers: Yekonga.Graphql.Resolvers,
introspection: false,
playground: false,
formatError: Yekonga.Graphql.Handler.error,
formatResponse: Yekonga.Graphql.Handler.response,
mocks: Yekonga.Graphql.Handler.mocks(),
preserveResolvers: true,
mockEntireSchema: false,
plugins: [ApolloServerPluginDrainHttpServer({ httpServer: Yekonga.serverSetup })],
};
const apiRoute = H.getApiRoute();
const middlewareConfig = { app: app, path: `${apiRoute}` };
// GraphiQL, a visual editor for queries
if (Yekonga.Config.apiPlaygroundEnable) {
SchemaConfig.introspection = true;
} else {
const file = path.join(__dirname, "../../", 'public/401.html');
app.get(`${apiRoute}`, (req, res) => {
res.sendFile(file)
})
}
const apolloServer = new ApolloServer(SchemaConfig);
await apolloServer.start();
// apolloServer.applyMiddleware(middlewareConfig);
app.use(
`${apiRoute}`,
cors(),
express.json(),
Yekonga.Graphql.Handler.formatMiddleware,
expressMiddleware(apolloServer, {
context: Yekonga.Helper.graphqlContext,
}),
);
Yekonga.Graphql.ApiController = apolloServer;
};
Yekonga.Graphql.authRoute = async (app) => {
let typeDefs = require('./graphql/auth/typeDefs.js');
let resolvers = require('./graphql/auth/resolvers');
var userRoles = [];
if (userCollection && userCollection.role) {
userRoles = userCollection.role.options;
if (!Array.isArray(userRoles)) {
if (userRoles && typeof userRoles == "object") {
var _userRoles = [];
for (const key in userRoles) {
_userRoles.push(key);
}
userRoles = _userRoles;
}
}
}
for (const key of userRoles) {
resolvers.Profile[H.getVariable('is_' + key)] = async function(parent, params, context) {
return (parent && parent.role == key);
}
}
if (Yekonga.Config.graphql && Yekonga.Config.graphql.customAuthTypes) {
var customTypes = path.join(serverLibrary.__dirname, Yekonga.Config.graphql.customAuthTypes);
if (fs.existsSync(customTypes)) {
typeDefs += fs.readFileSync(customTypes, { encoding: 'utf8' });
}
}
if (Yekonga.Config.graphql && Yekonga.Config.graphql.customAuthResolvers) {
var customResolversPath = path.join(serverLibrary.__dirname, Yekonga.Config.graphql.customAuthResolvers);
if (fs.existsSync(customResolversPath)) {
var customResolvers = require(customResolversPath);
for (const key in customResolvers) {
if (!resolvers[key]) {
resolvers[key] = customResolvers[key];
} else {
for (const queryKey in customResolvers[key]) {
resolvers[key][queryKey] = customResolvers[key][queryKey];
}
}
}
}
}
// GraphQL: Schema
const SchemaConfig = {
typeDefs: (typeDefs),
resolvers: resolvers,
introspection: false,
playground: false,
formatError: Yekonga.Graphql.Handler.error,
formatResponse: Yekonga.Graphql.Handler.response,
mocks: Yekonga.Graphql.Handler.mocks(),
preserveResolvers: true,
mockEntireSchema: false,
plugins: [ApolloServerPluginDrainHttpServer({ httpServer: Yekonga.serverSetup })],
};
const apiAuthRoute = H.getApiAuthRoute();
const middlewareConfig = { app: app, path: `${apiAuthRoute}` };
// GraphiQL, a visual editor for queries
if (Yekonga.Config.authPlaygroundEnable) {
SchemaConfig.introspection = true;
} else {
const file = path.join(__dirname, "../../", 'public/401.html');
app.get(`${apiAuthRoute}`, (req, res) => {
res.sendFile(file)
})
}
const apolloServer = new ApolloServer(SchemaConfig);
await apolloServer.start();
// apolloServer.applyMiddleware(middlewareConfig);
app.use(
`${apiAuthRoute}`,
cors(),
express.json(),
Yekonga.Graphql.Handler.formatMiddleware,
expressMiddleware(apolloServer, {
context: Yekonga.Helper.graphqlContext,
}),
);
Yekonga.Graphql.ApiAuthController = apolloServer;
};
}
setCloudFunction() {
// console.debug('Cloud Function set')
if (Yekonga.Config.cloud) {
const file = path.join(serverLibrary.__dirname, Yekonga.Config.cloud);
if (fs.existsSync(file)) {
require(file);
}
}
for (const row of Yekonga.Schema) {
const modeClass = H.getClass(row._id.collection);
Yekonga.Cloud.beforeFind(modeClass, Yekonga.Config.masterKey, async({ filter, Auth, Client, req, res }) => {
})
}
}
setDatabase() {
Yekonga.DB = Yekonga.DBbuilder(null);
Yekonga.Migration.load();
}
setDataGroups() {
Yekonga.Graphql.ResolverChartGroupData = {};
for (const row of Yekonga.Schema) {
const collection = row._id.collection;
const className = H.getClass(collection);
const primaryKey = H.getVariable(`${className}_id`, true);
const primaryName = H.getPrimaryName(row);
const fields = [];
for (const key in row) {
fields.push(key);
}
Yekonga.Graphql.ResolverChartGroupData[primaryKey] = {
collection,
className,
primaryKey,
primaryName,
fields,
}
}
}
}
module.exports.YekongaServer = YekongaServer;