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

package/tests/tenant.test.js

@@ -1,56 +0,0 @@
-const db = require("../db");
-const {
-  getState,
-  init_multi_tenant,
-  create_tenant,
-  restart_tenant,
-} = require("../db/state");
-getState().registerPlugin("base", require("../base-plugin"));
-const {
-  createTenant,
-  deleteTenant,
-  getAllTenants,
-} = require("../models/tenant");
-const {
-  getConfig,
-} = require("../models/config");
-
-afterAll(db.close);
-
-beforeAll(async () => {
-  if (!db.isSQLite) await db.query(`drop schema if exists test10 CASCADE `);
-});
-
-describe("Tenant", () => {
-  if (!db.isSQLite) {
-    it("can create a new tenant", async () => {
-      db.enable_multi_tenant();
-      getState().setConfig("base_url", "http://example.com/")
-      await create_tenant("test10", () => {}, "http://test10.example.com/");
-      db.runWithTenant("test10", async () => {
-        const ten = db.getTenantSchema();
-        expect(ten).toBe("test10");
-        const base =  await getConfig("base_url")
-        expect(base).toBe("http://test10.example.com/");
-
-      });
-      const tens = await getAllTenants();
-      expect(tens).toContain("test10");
-      expect(tens).not.toContain("public");
-      await init_multi_tenant(() => {});
-    });
-    it("can restart a tenant", async () => {
-      await db.runWithTenant("test10", async () => {
-        await restart_tenant(() => {});
-      });
-    });
-    it("can delete a tenant", async () => {
-      db.enable_multi_tenant();
-      await deleteTenant("test10");
-    });
-  } else {
-    it("does not support tenants on SQLite", async () => {
-      expect(db.isSQLite).toBe(true);
-    });
-  }
-});

package/tests/user.test.js

@@ -1,196 +0,0 @@
-const db = require("../db/index.js");
-const User = require("../models/user");
-const Table = require("../models/table");
-const Field = require("../models/field");
-
-const { getState } = require("../db/state");
-getState().registerPlugin("base", require("../base-plugin"));
-beforeAll(async () => {
-  await require("../db/reset_schema")();
-  await require("../db/fixtures")();
-});
-
-afterAll(db.close);
-
-describe("User", () => {
-  it("should create", async () => {
-    await User.create({ email: "foo@bar.com", password: "YEgege46gew" });
-    const u = await User.findOne({ email: "foo@bar.com" });
-    expect(u.email).toBe("foo@bar.com");
-    expect(u.password === "YEgege46gew").toBe(false);
-    const hasu = await User.nonEmpty();
-    expect(hasu).toBe(true);
-  });
-  it("should not create with common pw", async () => {
-    const res = await User.create({
-      email: "foo2@bar.com",
-      password: "passw0rd",
-    });
-    expect(!!res.error).toBe(true);
-  });
-  it("should authenticate", async () => {
-    const u = await User.authenticate({
-      email: "foo@bar.com",
-      password: "YEgege46gew",
-    });
-    expect(u.email).toBe("foo@bar.com");
-    expect(u.checkPassword("YEgege46gew")).toBe(true);
-    expect(u.checkPassword("foobar")).toBe(false);
-    const hpw = await User.hashPassword("YEgege46gew");
-    expect(hpw).not.toBe("YEgege46gew");
-    const u0 = await User.authenticate({
-      email: "foo@bar.com",
-      password: "secrat",
-    });
-    expect(u0).toBe(false);
-    const u00 = await User.authenticate({
-      email: "foo@baz.com",
-      password: "YEgege46gew",
-    });
-    expect(u00).toBe(false);
-  });
-  it("should reset password", async () => {
-    const u = await User.findOne({ email: "foo@bar.com" });
-    expect(u.session_object.email).toBe("foo@bar.com");
-    const token = await u.getNewResetToken();
-    expect(token.length > 10).toBe(true);
-    const res0 = await User.resetPasswordWithToken({
-      email: u.email,
-      reset_password_token: token,
-      password: "passw0rd",
-    });
-    expect(!!res0.success).toBe(false);
-    const res = await User.resetPasswordWithToken({
-      email: u.email,
-      reset_password_token: token,
-      password: "newpaass",
-    });
-    expect(!!res.success).toBe(true);
-    const u1 = await User.authenticate({
-      email: "foo@bar.com",
-      password: "YEgege46gew",
-    });
-    expect(!!u1).toBe(false);
-    const u2 = await User.authenticate({
-      email: "foo@bar.com",
-      password: "newpaass",
-    });
-    expect(!!u2).toBe(true);
-    const res1 = await User.resetPasswordWithToken({
-      email: u.email,
-      reset_password_token: "somerandomtoken",
-      password: "newpaass",
-    });
-    expect(res1).toEqual({ error: "User not found or expired token" });
-    const res2 = await User.resetPasswordWithToken({
-      email: u.email,
-      reset_password_token: "",
-      password: "newpaass",
-    });
-    expect(res2).toEqual({ error: "Invalid token or invalid token length or incorrect email" });
-  });
-  it("should reset API token", async () => {
-    const u = await User.findOne({ email: "foo@bar.com" });
-    const token = await u.getNewAPIToken();
-    expect(token.length > 5).toBe(true);
-    const u1 = await User.findOne({ email: "foo@bar.com" });
-    expect(u1.api_token).toEqual(token);
-    await u1.getNewAPIToken();
-    const u2 = await User.findOne({ email: "foo@bar.com" });
-    expect(u2.api_token).not.toEqual(token);
-  });
-  it("should set language ", async () => {
-    const u = await User.findOne({ email: "foo@bar.com" });
-    await u.set_language("fr");
-  });
-  it("should generate password ", async () => {
-    const rndpass = User.generate_password();
-    expect(typeof rndpass).toBe("string");
-    expect(rndpass.length).toBeGreaterThan(9);
-  });
-  it("should validate email", async () => {
-    expect(User.valid_email("foobar")).toBe(false);
-    expect(User.valid_email("foo@bar.com")).toBe(true);
-  });
-
-  it("should verify with token", async () => {
-    await getState().setConfig("elevate_verified", "4");
-
-    const u = await User.findOne({ email: "foo@bar.com" });
-    await u.update({ verification_token: "foobarbazfoobarbaz" });
-    expect(!!u.verified_on).toBe(false);
-    const res1 = await User.verifyWithToken({
-      email: "foo@bar.com",
-      verification_token: "foobar",
-    });
-    expect(res1.error).toBe("Invalid token");
-    const res2 = await User.verifyWithToken({
-      email: "foo@bar.com",
-      verification_token: "foobarbazfoobarbaz",
-    });
-    expect(res2).toBe(true);
-    const u2 = await User.findOne({ email: "foo@bar.com" });
-    expect(!!u2.verified_on).toBe(true);
-    expect(u2.role_id).toBe(4);
-  });
-  it("should count", async () => {
-    const n = await User.count();
-    expect(n).toBeGreaterThan(2);
-    expect(n).toBeLessThan(20);
-  });
-  it("should delete", async () => {
-    const u = await User.findOne({ email: "foo@bar.com" });
-    await u.delete();
-    const us = await User.find({ email: "foo@bar.com" });
-    expect(us.length).toBe(0);
-  });
-  it("should find or create by attribute ", async () => {
-    await getState().setConfig("email_mask", "yahoo.com");
-
-    const u = await User.findOrCreateByAttribute("googleId", 5, {
-      email: "tom@yahoo.com",
-    });
-    expect(typeof u.password).toBe("string");
-    const u1 = await User.findOrCreateByAttribute("googleId", 5);
-    expect(u.id).toEqual(u1.id);
-    expect(u1.email).toBe("tom@yahoo.com");
-    const res = await User.findOrCreateByAttribute("googleId", 7, {
-      email: "tomn@hey.com",
-    });
-    expect(res).toBe(false);
-    await getState().setConfig("new_user_form", "some_user_view");
-    const u2 = await User.findOrCreateByAttribute("googleId", 9, {
-      email: "foobar@yahoo.com",
-    });    
-    expect(!!u2.id).toBe(false)
-    await getState().setConfig("new_user_form", "");
-
-  });
-});
-
-describe("User fields", () => {
-  it("should add fields", async () => {
-    const table = await Table.findOne({ name: "users" });
-    const fc = await Field.create({
-      table,
-      label: "Height",
-      type: "Integer",
-    });
-    await User.create({
-      email: "foo1@bar.com",
-      password: "YEge56FGew",
-      height: 183,
-    });
-    const u = await User.authenticate({
-      email: "foo1@bar.com",
-      password: "YEge56FGew",
-    });
-    expect(u.email).toBe("foo1@bar.com");
-    expect(u.role_id).toBe(8);
-    expect(u.height).toBe(183);
-    expect(u.password === "YEge56FGew").toBe(false);
-    const ut = await table.getRow({ id: u.id });
-    expect(ut.email).toBe("foo1@bar.com");
-    expect(ut.height).toBe(183);
-  });
-});

package/tests/view.test.js

@@ -1,251 +0,0 @@
-const Table = require("../models/table");
-const Field = require("../models/field");
-const View = require("../models/view");
-const db = require("../db");
-const { plugin_with_routes, mockReqRes } = require("./mocks");
-const { getState } = require("../db/state");
-getState().registerPlugin("base", require("../base-plugin"));
-
-afterAll(db.close);
-beforeAll(async () => {
-  await require("../db/reset_schema")();
-  await require("../db/fixtures")();
-});
-
-describe("View", () => {
-  it("should run with no query", async () => {
-    const v = await View.findOne({ name: "authorlist" });
-    expect(v.min_role).toBe(10);
-    const res = await v.run({}, mockReqRes);
-    expect(res.length > 0).toBe(true);
-  });
-  it("should run on page", async () => {
-    const v = await View.findOne({ name: "authorlist" });
-    const res = await v.run_possibly_on_page({}, mockReqRes.req,  mockReqRes.res);
-    expect(res.length > 0).toBe(true);
-  });
-  it("should run with string query", async () => {
-    const v = await View.findOne({ name: "authorlist" });
-    const res = await v.run({ author: "Mel" }, mockReqRes);
-
-    expect(res.length > 0).toBe(true);
-  });
-  it("should run with integer query as int", async () => {
-    const v = await View.findOne({ name: "authorlist" });
-    const res = await v.run({ pages: 967 }, mockReqRes);
-
-    expect(res.length > 0).toBe(true);
-  });
-  it("should run with integer query as string", async () => {
-    const v = await View.findOne({ name: "authorlist" });
-    const res = await v.run({ pages: "967" }, mockReqRes);
-    expect(res.length > 0).toBe(true);
-  });
-  it("should render list state form", async () => {
-    const v = await View.findOne({ name: "authorlist" });
-    const res = await v.get_state_form({}, mockReqRes.req);
-    expect(res.constructor.name).toBe("Form");
-    expect(res.fields.length > 0).toBe(true);
-  });
-  it("should get config flow", async () => {
-    const v = await View.findOne({ name: "authorlist" });
-    const res = await v.get_config_flow({ __: (s) => s });
-    expect(res.constructor.name).toBe("Workflow");
-    expect(res.steps.length > 0).toBe(true);
-  });
-  it("should runMany with no query", async () => {
-    const v = await View.findOne({ name: "authorshow" });
-    const res = await v.runMany({}, mockReqRes);
-    expect(res.length > 0).toBe(true);
-  });
-  it("should runPost", async () => {
-    const v = await View.findOne({ name: "authoredit" });
-    await v.runPost({}, { author: "James Joyce" }, mockReqRes);
-    const rows = await db.select("books", {});
-    expect(rows).toContainEqual({ author: "James Joyce", id: 3, pages: 678 });
-  });
-  it("should find", async () => {
-    const table = await Table.findOne({ name: "books" });
-    const link_views = await View.find({
-      table_id: table.id,
-    });
-    expect(link_views.length).toBe(3);
-  });
-  it("should find where", async () => {
-    const link_views = await View.find_all_views_where(
-      ({ viewrow }) => viewrow.name === "authorshow"
-    );
-    expect(link_views.length).toBe(1);
-  });
-  it("should create and delete", async () => {
-    const table = await Table.findOne({ name: "books" });
-
-    const v = await View.create({
-      table_id: table.id,
-      name: "anewview",
-      viewtemplate: "List",
-      configuration: { columns: [], default_state: { foo: "bar" } },
-      min_role: 10,
-    });
-    expect(typeof v.id).toBe("number");
-    expect(typeof v.viewtemplateObj).toBe("object");
-
-    const st = v.combine_state_and_default_state({ baz: 3 });
-    expect(st).toStrictEqual({ baz: 3, foo: "bar" });
-    await v.delete();
-    const v1 = await View.create({
-      table_id: table.id,
-      name: "anewview",
-      viewtemplate: "List",
-      configuration: { columns: [], default_state: { foo: "bar" } },
-      min_role: 10,
-    });
-    await View.update({name: "anewestview"}, v1.id)
-    await View.delete({name: "anewestview"})
-  });
-  it("should clone", async () => {
-    const v = await View.findOne({ name: "authorlist" });
-    await v.clone();
-    const v1 = await View.findOne({ name: "authorlist copy" });
-    expect(!!v1).toBe(true);
-    const res = await v1.run({ author: "Mel" }, mockReqRes);
-
-    expect(res.length > 0).toBe(true);
-  });
-});
-describe("View with routes", () => {
-  it("should create and delete", async () => {
-    getState().registerPlugin("mock_plugin", plugin_with_routes);
-    expect(getState().viewtemplates.ViewWithRoutes.name).toBe("ViewWithRoutes");
-    var html, json;
-    const spy = {
-      send(h) {
-        html = h;
-      },
-      json(h) {
-        json = h;
-      },
-    };
-    const table = await Table.findOne({ name: "books" });
-
-    const v = await View.create({
-      table_id: table.id,
-      name: "aviewwithroutes",
-      viewtemplate: "ViewWithRoutes",
-      configuration: {},
-      min_role: 10,
-    });
-    await v.runRoute("the_json_route", {}, spy, mockReqRes);
-    await v.runRoute("the_html_route", {}, spy, mockReqRes);
-    await v.runRoute("the_null_route", {}, spy, mockReqRes);
-    expect(json).toEqual({ success: "ok" });
-    expect(html).toEqual("<div>Hello</div>");
-
-    const sf = await v.get_state_form({}, mockReqRes.req);
-    expect(sf).toBe(null);
-  });
-});
-describe("nested views", () => {
-  it("should create and run", async () => {
-    const table = await Table.findOne({ name: "books" });
-
-    const small = await View.create({
-      table_id: table.id,
-      name: "small",
-      viewtemplate: "Show",
-      configuration: {
-        layout: {
-          above: [
-            {
-              aligns: ["left", "left"],
-              widths: [2, 10],
-              besides: [
-                { above: [null, { type: "blank", contents: "Pages" }] },
-                {
-                  above: [
-                    null,
-                    { type: "field", fieldview: "show", field_name: "pages" },
-                  ],
-                },
-              ],
-            },
-            { type: "line_break" },
-          ],
-        },
-        columns: [{ type: "Field", fieldview: "show", field_name: "pages" }],
-        viewname: "small",
-      },
-      min_role: 10,
-    });
-    const medium = await View.create({
-      table_id: table.id,
-      name: "medium",
-      viewtemplate: "Show",
-      configuration: {
-        layout: {
-          above: [
-            {
-              aligns: ["left", "left"],
-              widths: [2, 10],
-              besides: [
-                { above: [null, { type: "blank", contents: "Author" }] },
-                {
-                  above: [
-                    null,
-                    {
-                      type: "field",
-                      fieldview: "as_text",
-                      field_name: "author",
-                    },
-                  ],
-                },
-              ],
-            },
-            { type: "line_break" },
-            { name: "64063e", type: "view", view: "small", state: "shared" },
-          ],
-        },
-        columns: [
-          { type: "Field", fieldview: "as_text", field_name: "author" },
-        ],
-        viewname: "medium",
-      },
-      min_role: 10,
-    });
-    const res = await medium.run({ id: 2 }, mockReqRes);
-
-    expect(res).toContain("Tolstoy");
-    expect(res).toContain("728");
-    expect(res).not.toContain("967");
-    expect(res).not.toContain("Melville");
-  });
-  it("should create and run feed of nested", async () => {
-    const table = await Table.findOne({ name: "books" });
-
-    const large = await View.create({
-      table_id: table.id,
-      name: "large",
-      viewtemplate: "Feed",
-      configuration: {
-        cols_lg: 1,
-        cols_md: 1,
-        cols_sm: 1,
-        cols_xl: 1,
-        in_card: false,
-        viewname: "large",
-        show_view: "medium",
-        descending: false,
-        order_field: "author",
-        view_to_create: "",
-        create_view_display: "Link",
-      },
-      min_role: 10,
-    });
-    const res = await large.run({}, mockReqRes);
-
-    expect(res).toContain("Tolstoy");
-    expect(res).toContain("728");
-    expect(res).toContain("967");
-    expect(res).toContain("Melville");
-  });
-});

package/tests/workflow.test.js

@@ -1,119 +0,0 @@
-const Form = require("../models/form");
-const Field = require("../models/field");
-const View = require("../models/view");
-const Workflow = require("../models/workflow");
-const db = require("../db");
-
-const { getState } = require("../db/state");
-getState().registerPlugin("base", require("../base-plugin"));
-const { mockReqRes } = require("./mocks");
-
-afterAll(db.close);
-
-const wf = new Workflow({
-  steps: [
-    {
-      name: "step1",
-      form: async (context) => {
-        return new Form({
-          blurb: "Specify the fields in the table to show",
-          fields: [{ name: "colour", label: "Colour", input_type: "text" }],
-        });
-      },
-    },
-    {
-      name: "step2",
-      contextField: "substep",
-      form: async (context) => {
-        return new Form({
-          blurb: "Specify the fields in the table to show",
-          fields: [
-            { name: "age", label: "Age", type: "Integer", required: true },
-          ],
-        });
-      },
-    },
-  ],
-});
-const wf1 = new Workflow({
-  steps: [
-    {
-      name: "step1",
-      form: async (context) => {
-        return new Form({
-          blurb: "Specify the fields in the table to show",
-          fields: [
-            { name: "colour", label: "Colour", input_type: "text" },
-            { name: "is_nice", type: "Bool" },
-          ],
-        });
-      },
-    },
-  ],
-});
-
-const wfbuild = new Workflow({
-  steps: [
-    {
-      name: "step1",
-      builder: async (context) => {
-        return { mode: "foo" };
-      },
-    },
-  ],
-});
-
-describe("Workflow", () => {
-  it("should run with context", async () => {
-    const v = await wf.run({ foo: "bar" });
-    expect(v.renderForm.values.contextEnc).toContain("bar");
-    const hiddenFields = v.renderForm.fields
-      .filter((f) => f.input_type === "hidden")
-      .map((f) => f.name);
-    expect(hiddenFields).toContain("contextEnc");
-    var submit = { colour: "Blue" };
-    hiddenFields.forEach((f) => {
-      submit[f] = v.renderForm.values[f];
-    });
-    const v1 = await wf.run(submit);
-    expect(v1.renderForm.values.contextEnc).toContain("bar");
-
-    const hiddenFields1 = v1.renderForm.fields
-      .filter((f) => f.input_type === "hidden")
-      .map((f) => f.name);
-    expect(hiddenFields1).toContain("contextEnc");
-    var submit1 = { age: "67" };
-    hiddenFields1.forEach((f) => {
-      submit1[f] = v1.renderForm.values[f];
-    });
-    const v2 = await wf.run(submit1);
-    expect(v2).toStrictEqual({
-      colour: "Blue",
-      foo: "bar",
-      substep: { age: 67 },
-    });
-    var submit_missing = {};
-    hiddenFields1.forEach((f) => {
-      submit_missing[f] = v1.renderForm.values[f];
-    });
-    const v3 = await wf.run(submit_missing);
-    expect(v3.renderForm.values.contextEnc).toContain("bar");
-  });
-  it("should run with existing", async () => {
-    const v = await wf1.run({ colour: "purple", is_nice: "on" });
-    expect(v.renderForm.values.colour).toBe("purple");
-    expect(v.renderForm.values.is_nice).toBe(true);
-  });
-  it("should run builder", async () => {
-    const v = await wfbuild.run({});
-    expect(v.renderBuilder.mode).toBe("foo");
-    var submit1 = {
-      layout: encodeURIComponent("{}"),
-      columns: encodeURIComponent("{}"),
-      stepName: v.stepName,
-      contextEnc: encodeURIComponent(JSON.stringify(v.context)),
-    };
-    const v2 = await wfbuild.run(submit1);
-    expect(v2).toEqual({ columns: {}, layout: {} });
-  });
-});