@saltcorn/data 0.6.2-beta.1 → 0.6.2-beta.2

package/models/crash.js

@@ -1,126 +0,0 @@
-/**
- * Crash Database Access Layer
- * @category saltcorn-data
- * @module models/crash
- * @subcategory models
- */
-const db = require("../db");
-const moment = require("moment");
-const { contract, is } = require("contractis");
-
-/**
- * Crash Class
- * @category saltcorn-data
- */
-class Crash {
-  /**
-    * Crash constructor
-    * @param {object} o
-    */
-  constructor(o) {
-    this.id = o.id;
-    this.stack = o.stack;
-    this.message = o.message;
-    this.occur_at = ["string", "number"].includes(typeof o.occur_at)
-      ? new Date(o.occur_at)
-      : o.occur_at;
-    this.tenant = o.tenant;
-    this.user_id = o.user_id;
-    this.body = o.body;
-    this.url = o.url;
-    this.headers =
-      typeof o.headers === "string" ? JSON.parse(o.headers) : o.headers;
-    contract.class(this);
-  }
-
-  /**
-   * @param {object} where 
-   * @param {object} selopts 
-   * @returns {Promise<Crash[]>}
-   */
-  static async find(where, selopts) {
-    const us = await db.select("_sc_errors", where, selopts);
-    return us.map((u) => new Crash(u));
-  }
-
-  /**
-   * @param {object} where 
-   * @returns {Promise<Crash>}
-   */
-  static async findOne(where) {
-    const u = await db.selectOne("_sc_errors", where);
-    return new Crash(u);
-  }
-
-  /**
-   * @type {string}
-   */
-  get reltime() {
-    return moment(this.occur_at).fromNow();
-  }
-
-  /**
-   * @param {object} where 
-   * @returns {Promise<number>}
-   */
-  static async count(where) {
-    return await db.count("_sc_errors", where || {});
-  }
-
-  /**
-   * @type {string}
-   */
-  get msg_short() {
-    return this.message.length > 90
-      ? this.message.substring(0, 90)
-      : this.message;
-  }
-
-  /**
-   * @param {object} err 
-   * @param {object} [req = {}]
-   * @returns {Promise<void>}
-   */
-  static async create(err, req = {}) {
-    const schema = db.getTenantSchema();
-    const payload = {
-      stack: err.stack,
-      message: err.message,
-      occur_at: new Date(),
-      tenant: schema,
-      user_id: req.user ? req.user.id : null,
-      body: req.body ? { body: req.body } : null,
-      url: req.url,
-      headers: req.headers,
-    };
-    await db.runWithTenant(db.connectObj.default_schema, async () => {
-      await db.insert("_sc_errors", payload);
-    });
-    const Trigger = require("./trigger");
-
-    Trigger.emitEvent("Error", null, req.user, payload);
-  }
-}
-
-Crash.contract = {
-  variables: {
-    id: is.maybe(is.posint),
-    user_id: is.maybe(is.posint),
-    stack: is.str,
-    message: is.str,
-    tenant: is.str,
-    url: is.str,
-    occur_at: is.class("Date"),
-    headers: is.obj(),
-  },
-  methods: {
-    reltime: is.getter(is.str),
-  },
-  static_methods: {
-    find: is.fun(is.obj(), is.promise(is.array(is.class("Crash")))),
-    findOne: is.fun(is.obj(), is.promise(is.class("Crash"))),
-    create: is.fun([is.obj(), is.obj()], is.promise(is.any)),
-  },
-};
-
-module.exports = Crash;

package/models/discovery.js

@@ -1,195 +0,0 @@
-/**
- * DB Tables discovery to Saltcorn tables.
- * @category saltcorn-data
- * @module models/discovery
- * @subcategory models
- */
-const db = require("../db");
-const { getState } = require("../db/state");
-const { available_languages } = require("./config");
-const Table = require("./table");
-
-// create table discmetable(id serial primary key, name text, age integer not null); ALTER TABLE discmetable OWNER TO tomn;
-/**
- * List of discoverable tables.
- * Returns all tables that can be imported to Saltcorn from current tenant database schema.
- * The tables with name started with "_sc_" and tables imported to Saltcorn are ignored.
- * @param {string} schema0 - current tenant db schema
- * @returns {Promise<object[]>} all tables that can be imported to Saltcorn from current tenant database schema
- */
-const discoverable_tables = async (schema0) => {
-  const schema = schema0 || db.getTenantSchema();
-  const {
-    rows,
-  } = await db.query(
-    "select * from information_schema.tables where table_schema=$1 order by table_name",
-    [schema]
-  );
-  const myTables = await Table.find({});
-  const myTableNames = myTables.map((t) => t.name);
-  const discoverable = rows.filter(
-    (t) =>
-      !(myTableNames.includes(t.table_name) || t.table_name.startsWith("_sc_"))
-  );
-  return discoverable;
-};
-/**
- * List all views in current  tenant db schema
- * @param {string} schema0 - current tenant db schema
- * @returns {Promise<object[]>} Return list of views
- */
-const get_existing_views = async (schema0) => {
-  const schema = schema0 || db.getTenantSchema();
-  const {
-    rows,
-  } = await db.query(
-    "select * from information_schema.views where table_schema=$1",
-    [schema]
-  );
-  return rows;
-};
-/**
- * Mapping SQL Type to Saltcorn type
- * @param {string} sql_name - SQL type name
- * @returns {string|void} return Saltcorn type
- */
-const findType = (sql_name) => {
-  const fixed = {
-    integer: "Integer",
-    smallint: "Integer",
-    bigint: "Integer",
-    numeric: "Float", // required pres
-    character: "String", // char - if length is not defined is 1 else length needs to be defined
-    "character varying": "String", // varchar  - this type can have length
-    //varchar: "String",
-    date: "Date"
-    // TBD Implement time type in Saltcorn
-    // "time without time zone": "Date",
-    // TBD Implement timestamp type in Saltcorn
-    // "timestamp without time zone": "Date",
-    // TBD Implement time interval in Saltcorn
-    // interval: "Date"
-  }[sql_name];
-  if (fixed) return fixed;
-  const t = Object.entries(getState().types).find(
-    ([k, v]) => v.sql_name === sql_name
-  );
-  if (t) {
-    return t[0];
-  }
-};
-/**
- * Discover tables definitions
- * @param {string[]} tableNames - list of table names
- * @param {string} schema0 - db schema
- * @returns {Promise<object>}
- */
-const discover_tables = async (tableNames, schema0) => {
-  const schema = schema0 || db.getTenantSchema();
-  const packTables = [];
-
-  for (const tnm of tableNames) {
-    const {
-      rows,
-    } = await db.query(
-      "select * from information_schema.columns where table_schema=$1 and table_name=$2",
-      [schema, tnm]
-    );
-    // TBD add logic about column length, scale, etc
-    const fields = rows
-      .map((c) => ({
-        name: c.column_name,
-        label: c.column_name,
-        type: findType(c.data_type),
-        required: c.is_nullable === "NO",
-      }))
-      .filter((f) => f.type);
-
-    // try to find column name for primary key of table
-    const pkq = await db.query(
-      `SELECT c.column_name
-      FROM information_schema.table_constraints tc 
-      JOIN information_schema.constraint_column_usage AS ccu USING (constraint_schema, constraint_name) 
-      JOIN information_schema.columns AS c ON c.table_schema = tc.constraint_schema
-        AND tc.table_name = c.table_name AND ccu.column_name = c.column_name
-      WHERE constraint_type = 'PRIMARY KEY' and tc.table_schema=$1 and tc.table_name = $2;`,
-      [schema, tnm]
-    );
-    // set primary_key and unique attributes for column
-    pkq.rows.forEach(({ column_name }) => {
-      const field = fields.find((f) => f.name === column_name);
-      field.primary_key = true;
-      field.is_unique = true;
-    });
-    // try to find foreign keys
-    const fkq = await db.query(
-      `SELECT
-      tc.table_schema, 
-      tc.constraint_name, 
-      tc.table_name, 
-      kcu.column_name, 
-      ccu.table_schema AS foreign_table_schema,
-      ccu.table_name AS foreign_table_name,
-      ccu.column_name AS foreign_column_name 
-  FROM 
-      information_schema.table_constraints AS tc 
-      JOIN information_schema.key_column_usage AS kcu
-        ON tc.constraint_name = kcu.constraint_name
-        AND tc.table_schema = kcu.table_schema
-      JOIN information_schema.constraint_column_usage AS ccu
-        ON ccu.constraint_name = tc.constraint_name
-        AND ccu.table_schema = tc.table_schema
-  WHERE tc.constraint_type = 'FOREIGN KEY' and tc.table_schema=$1 AND tc.table_name=$2;`,
-      [schema, tnm]
-    );
-    // construct foreign key relations
-    fkq.rows.forEach(
-      ({ column_name, foreign_table_name, foreign_column_name }) => {
-        const field = fields.find((f) => f.name === column_name);
-        field.type = "Key";
-        field.reftable_name = foreign_table_name;
-        field.refname = foreign_column_name;
-      }
-    );
-
-    packTables.push({ name: tnm, fields, min_role_read: 1, min_role_write: 1 });
-  }
-  packTables.forEach((t) => {
-    t.fields.forEach((f) => {
-      if (f.type === "Key") {
-        const reftable = packTables.find(
-          (reft) => reft.name === f.reftable_name
-        );
-        const refpk = reftable.fields.find((rtf) => rtf.primary_key);
-        f.reftype = refpk.type;
-      }
-    });
-  });
-  return { tables: packTables };
-};
-/**
- * Add discovered tables to Saltcorn
- * @param {object} pack - table definition
- * @returns {Promise<void>}
- */
-const implement_discovery = async (pack) => {
-  for (const table of pack.tables) {
-    const { fields, ...tblRow } = table;
-    const id = await db.insert("_sc_tables", tblRow);
-    table.id = id;
-  }
-  for (const table of pack.tables) {
-    for (const field of table.fields) {
-      await db.insert("_sc_fields", { ...field, table_id: table.id });
-    }
-  }
-  // refresh Saltcorn table list (in memory)
-  await require("../db/state").getState().refresh_tables();
-
-};
-module.exports = {
-  discoverable_tables,
-  discover_tables,
-  implement_discovery,
-  get_existing_views,
-};

package/models/email.js

@@ -1,92 +0,0 @@
-/**
- * @category saltcorn-data
- * @module models/email
- * @subcategory models
- */
-const nodemailer = require("nodemailer");
-const { getState } = require("../db/state");
-const BootstrapEmail = require("bootstrap-email");
-const tmp = require("tmp-promise");
-const fs = require("fs").promises;
-const { div } = require("@saltcorn/markup/tags");
-const View = require("./view");
-const { v4: uuidv4 } = require("uuid");
-const db = require("../db");
-const { mockReqRes } = require("../tests/mocks");
-
-/**
- * @returns {Transporter}
- */
-const getMailTransport = () => {
-  const port = getState().getConfig("smtp_port");
-  const secure = getState().getConfig("smtp_secure", port === 465);
-  return nodemailer.createTransport({
-    host: getState().getConfig("smtp_host"),
-    port,
-    secure,
-    auth: {
-      user: getState().getConfig("smtp_username"),
-      pass: getState().getConfig("smtp_password"),
-    },
-  });
-};
-
-/**
- * @param {object} bsHtml 
- * @returns {object}
- */
-const transformBootstrapEmail = async (bsHtml) => {
-  const filename = await tmp.tmpName();
-  await fs.writeFile(filename, div({ class: "container" }, bsHtml));
-
-  const template = new BootstrapEmail(filename);
-  const email = template.compile();
-  await fs.unlink(filename);
-  return email;
-};
-
-/**
- * @param {object} user 
- * @param {object} [req]
- * @returns {Promise<object>}
- */
-const send_verification_email = async (user, req) => {
-  const verification_view_name = getState().getConfig("verification_view");
-  if (verification_view_name) {
-    const verification_view = await View.findOne({
-      name: verification_view_name,
-    });
-    if (verification_view) {
-      const verification_token = uuidv4();
-      try {
-        await db.update("users", { verification_token }, user.id);
-        user.verification_token = verification_token;
-        const htmlBs = await verification_view.run({ id: user.id }, mockReqRes);
-        const html = await transformBootstrapEmail(htmlBs);
-        const email = {
-          from: getState().getConfig("email_from"),
-          to: user.email,
-          subject: "Please verify your email address",
-          html,
-        };
-        await getMailTransport().sendMail(email);
-        if (req)
-          req.flash(
-            "success",
-            req.__("An email has been sent to %s to verify your address", user.email)
-          );
-        return true;
-      } catch (e) {
-        return { error: e.message };
-      }
-    } else return { error: "Verification form specified but not found" };
-  } else {
-    return { error: "Verification form not specified" };
-  }
-};
-
-module.exports = {
-  getMailTransport,
-  transformBootstrapEmail,
-  send_verification_email,
-};

package/models/eventlog.js

@@ -1,146 +0,0 @@
-/**
- * EventLog Database Access Layer
- * @category saltcorn-data
- * @module models/eventlog
- * @subcategory models
- */
-const db = require("../db");
-const moment = require("moment");
-
-const { contract, is } = require("contractis");
-
-/**
- * EventLog Class
- * @category saltcorn-data
- */
-class EventLog {
-  /**
-   * EventLog constructor
-   * @param {object} o 
-   */
-  constructor(o) {
-    this.id = o.id;
-    this.event_type = o.event_type;
-    this.channel = o.channel;
-    this.occur_at = ["string", "number"].includes(typeof o.occur_at)
-      ? new Date(o.occur_at)
-      : o.occur_at;
-    this.user_id = o.user_id;
-    this.payload =
-      typeof o.payload === "string" ? JSON.parse(o.payload) : o.payload;
-    contract.class(this);
-  }
-
-  /**
-   * @param {object} where 
-   * @param {object} selopts 
-   * @returns {Promise<EventLog[]>}
-   */
-  static async find(where, selopts) {
-    const us = await db.select("_sc_event_log", where, selopts);
-    return us.map((u) => new EventLog(u));
-  }
-
-  /**
-   * @param {object} where 
-   * @returns {Promise<EventLog>}
-   */
-  static async findOne(where) {
-    const u = await db.selectOne("_sc_event_log", where);
-    return new EventLog(u);
-  }
-
-  /**
-   * @param {string} id 
-   * @returns {Promise<EventLog>}
-   */
-  static async findOneWithUser(id) {
-    const {
-      rows,
-    } = await db.query(
-      "select el.*, u.email from _sc_event_log el left join users u on el.user_id = u.id where el.id = $1",
-      [id]
-    );
-    const u = rows[0];
-    const el = new EventLog(u);
-    el.email = u.email;
-    return el;
-  }
-
-  /**
-   * @param {object} where 
-   * @returns {Promise<number>}
-   */
-  static async count(where) {
-    return await db.count("_sc_event_log", where || {});
-  }
-
-  /**
-    * @type {string}
-    */
-  get reltime() {
-    return moment(this.occur_at).fromNow();
-  }
-
-  /**
-   * @param {object} o 
-   * @returns {Promise<EventLog>}
-   */
-  static async create(o) {
-    const { getState } = require("../db/state");
-
-    const settings = getState().getConfig("event_log_settings", {});
-    if (!settings[o.event_type]) return;
-    const hasTable = EventLog.hasTable(o.event_type);
-    if (hasTable && !settings[`${o.event_type}_${o.channel}`]) return;
-    const hasChannel = EventLog.hasChannel(o.event_type);
-    if (hasChannel && settings[`${o.event_type}_channel`]) {
-      const wantChannels = settings[`${o.event_type}_channel`]
-        .split(",")
-        .map((s) => s.trim());
-      if (!wantChannels.includes(o.channel)) return;
-    }
-    const ev = new EventLog(o);
-    const { id, ...rest } = ev;
-
-    ev.id = await db.insert("_sc_event_log", rest);
-    return ev;
-  }
-
-  /**
-   * @param {string} evType 
-   * @returns {boolean}
-   */
-  static hasTable(evType) {
-    return ["Insert", "Update", "Delete"].includes(evType);
-  }
-
-  /**
-   * @param {string} evType 
-   * @returns {boolean}
-   */
-  static hasChannel(evType) {
-    const { getState } = require("../db/state");
-    const t = getState().eventTypes[evType];
-    return t && t.hasChannel;
-  }
-}
-
-EventLog.contract = {
-  variables: {
-    id: is.maybe(is.posint),
-    event_type: is.str,
-    channel: is.maybe(is.str),
-    occur_at: is.class("Date"),
-    user_id: is.maybe(is.posint),
-    payload: is.maybe(is.obj()),
-  },
-  methods: {},
-  static_methods: {
-    find: is.fun(is.obj(), is.promise(is.array(is.class("EventLog")))),
-    findOne: is.fun(is.obj(), is.promise(is.class("EventLog"))),
-    create: is.fun(is.obj(), is.promise(is.any)),
-  },
-};
-
-module.exports = EventLog;