@actual-app/core 26.3.0

package/src/server/aql/schema-helpers.ts

@@ -0,0 +1,208 @@
+// @ts-strict-ignore
+import { dayFromDate } from '../../shared/months';
+import { fromDateRepr, toDateRepr } from '../models';
+
+function isRequired(name, fieldDesc) {
+  return fieldDesc.required || name === 'id';
+}
+
+// TODO: All of the data type needs to check the input value. This
+// doesn't just convert, it casts. See integer handling.
+export function convertInputType(value, type) {
+  if (value === undefined) {
+    throw new Error('Query value cannot be undefined');
+  } else if (value === null) {
+    if (type === 'boolean') {
+      return 0;
+    }
+
+    return null;
+  }
+
+  switch (type) {
+    case 'date':
+      if (value instanceof Date) {
+        return toDateRepr(dayFromDate(value));
+      } else if (
+        value.match(/^\d{4}-\d{2}-\d{2}$/) == null ||
+        value < '1995-01-01'
+      ) {
+        throw new Error('Invalid date: ' + value);
+      }
+
+      return toDateRepr(value);
+    case 'date-month':
+      return toDateRepr(value.slice(0, 7));
+    case 'date-year':
+      return toDateRepr(value.slice(0, 4));
+    case 'boolean':
+      return value ? 1 : 0;
+    case 'id':
+      if (typeof value !== 'string' && value !== null) {
+        throw new Error('Invalid id, must be string: ' + value);
+      }
+      return value;
+    case 'integer':
+      if (typeof value === 'number' && Number.isInteger(value)) {
+        return value;
+      } else {
+        throw new Error("Can't convert to integer: " + JSON.stringify(value));
+      }
+    case 'json':
+      return JSON.stringify(value);
+    default:
+  }
+  return value;
+}
+
+export function convertOutputType(value, type) {
+  if (value === null) {
+    if (type === 'boolean') {
+      return false;
+    }
+    return null;
+  }
+
+  switch (type) {
+    case 'date':
+      return fromDateRepr(value);
+    case 'date-month':
+      return fromDateRepr(value).slice(0, 7);
+    case 'date-year':
+      return fromDateRepr(value).slice(0, 4);
+    case 'boolean':
+      return value === 1;
+    case 'json':
+    case 'json/fallback':
+      try {
+        return JSON.parse(value);
+      } catch {
+        return type === 'json/fallback' ? value : null;
+      }
+    default:
+  }
+
+  return value;
+}
+
+export function conform(
+  schema,
+  schemaConfig,
+  table,
+  obj,
+  { skipNull = false } = {},
+) {
+  const tableSchema = schema[table];
+  if (tableSchema == null) {
+    throw new Error(`Table "${table}" does not exist`);
+  }
+
+  const views = schemaConfig.views || {};
+
+  // Rename fields if necessary
+  const fieldRef = field => {
+    if (views[table] && views[table].fields) {
+      return views[table].fields[field] || field;
+    }
+    return field;
+  };
+
+  return Object.fromEntries(
+    Object.keys(obj)
+      .map(field => {
+        // Fields that start with an underscore are ignored
+        if (field[0] === '_') {
+          return null;
+        }
+
+        const fieldDesc = tableSchema[field];
+        if (fieldDesc == null) {
+          throw new Error(
+            `Field "${field}" does not exist on table ${table}: ${JSON.stringify(
+              obj,
+            )}`,
+          );
+        }
+
+        if (isRequired(field, fieldDesc) && obj[field] == null) {
+          throw new Error(
+            `"${field}" is required for table "${table}": ${JSON.stringify(
+              obj,
+            )}`,
+          );
+        }
+
+        // This option removes null values (see `convertForInsert`)
+        if (skipNull && obj[field] == null) {
+          return null;
+        }
+
+        return [fieldRef(field), convertInputType(obj[field], fieldDesc.type)];
+      })
+      .filter(Boolean),
+  );
+}
+
+export function convertForInsert(schema, schemaConfig, table, rawObj) {
+  const obj = { ...rawObj };
+
+  const tableSchema = schema[table];
+  if (tableSchema == null) {
+    throw new Error(`Error inserting: table "${table}" does not exist`);
+  }
+
+  // Inserting checks all the fields in the table and adds any default
+  // values necessary
+  Object.keys(tableSchema).forEach(field => {
+    const fieldDesc = tableSchema[field];
+
+    if (obj[field] == null) {
+      if (fieldDesc.default !== undefined) {
+        obj[field] =
+          typeof fieldDesc.default === 'function'
+            ? fieldDesc.default()
+            : fieldDesc.default;
+      } else if (isRequired(field, fieldDesc)) {
+        // Although this check is also done in `conform`, it only
+        // checks the fields in `obj`. For insert, we need to do it
+        // here to check that all required fields in the table exist
+        throw new Error(
+          `"${field}" is required for table "${table}": ${JSON.stringify(obj)}`,
+        );
+      }
+    }
+  });
+
+  // We use `skipNull` to remove any null values. There's no need to
+  // set those when inserting, that will be the default and it reduces
+  // the amount of messages generated to sync
+  return conform(schema, schemaConfig, table, obj, { skipNull: true });
+}
+
+export function convertForUpdate(schema, schemaConfig, table, rawObj) {
+  const obj = { ...rawObj };
+
+  const tableSchema = schema[table];
+  if (tableSchema == null) {
+    throw new Error(`Error updating: table "${table}" does not exist`);
+  }
+
+  return conform(schema, schemaConfig, table, obj);
+}
+
+export function convertFromSelect(schema, schemaConfig, table, obj) {
+  const tableSchema = schema[table];
+  if (tableSchema == null) {
+    throw new Error(`Table "${table}" does not exist`);
+  }
+
+  const fields = Object.keys(tableSchema);
+  const result = {};
+  for (let i = 0; i < fields.length; i++) {
+    const fieldName = fields[i];
+    const fieldDesc = tableSchema[fieldName];
+
+    result[fieldName] = convertOutputType(obj[fieldName], fieldDesc.type);
+  }
+  return result;
+}

package/src/server/aql/views.test.ts

@@ -0,0 +1,62 @@
+// @ts-strict-ignore
+import * as db from '../db';
+
+import { makeViews } from './views';
+
+beforeEach(global.emptyDatabase());
+
+const schema = {
+  transactions: {
+    id: { type: 'id' },
+    amount: { type: 'integer' },
+    transfer_id: { type: 'integer' },
+  },
+};
+
+const schemaConfig = {
+  views: {
+    transactions: {
+      fields: {
+        amount: 'a_mo_unt',
+      },
+
+      v_transactions1: internalFields => {
+        const fields = internalFields({
+          transfer_id: 'CASE WHEN amount < 4 THEN null ELSE transfer_id END',
+        });
+
+        return `SELECT ${fields} FROM transactions`;
+      },
+
+      v_transactions2: (_, publicFields) => {
+        const fields = publicFields({
+          transfer_id: 'COERCE(transfer_id, "foo")',
+        });
+
+        return `SELECT ${fields} FROM v_transactions1`;
+      },
+    },
+  },
+};
+
+describe('schema views', () => {
+  test('generates views with all the right fields', () => {
+    const str = makeViews(schema, schemaConfig);
+    expect(str).toMatch('DROP VIEW IF EXISTS v_transactions1;');
+    expect(str).toMatch(
+      'CREATE VIEW v_transactions1 AS SELECT _.id, _.a_mo_unt AS amount, CASE WHEN amount < 4 THEN null ELSE transfer_id END AS transfer_id FROM transactions;',
+    );
+    expect(str).toMatch('DROP VIEW IF EXISTS v_transactions2;');
+    expect(str).toMatch(
+      'CREATE VIEW v_transactions2 AS SELECT _.id, _.amount, COERCE(transfer_id, "foo") AS transfer_id FROM v_transactions1;',
+    );
+
+    db.execQuery('DROP TABLE transactions');
+    db.execQuery(
+      'CREATE TABLE transactions (id TEXT PRIMARY KEY, a_mo_unt INTEGER, transfer_id TEXT)',
+    );
+
+    // Make sure the string is valid SQL
+    db.execQuery(str);
+  });
+});

package/src/server/aql/views.ts

@@ -0,0 +1,57 @@
+// @ts-strict-ignore
+import { quoteAlias } from './compiler';
+
+function selectFields(fields) {
+  return Object.keys(fields)
+    .map(as => {
+      let field = fields[as];
+      const needsAs = field !== as;
+      // If it's just an identifier, we automatically prefix it with
+      // `_.` which makes sure it references the root table
+      if (!field.match(/[ .]/)) {
+        field = `_.${field}`;
+      }
+      return needsAs ? `${field} AS ${quoteAlias(as)}` : `${field}`;
+    })
+    .join(', ');
+}
+
+export function makeViews(schema, schemaConfig) {
+  const views = schemaConfig.views;
+  const viewStrs = [];
+
+  Object.keys(views).forEach(table => {
+    const { fields: fieldMappings = {}, ...tableViews } = views[table];
+
+    const publicFields = Object.fromEntries(
+      Object.keys(schema[table]).map(name => [name, name]),
+    );
+    const internalFields = { ...publicFields, ...fieldMappings };
+
+    Object.keys(tableViews).forEach(viewName => {
+      const publicMaker = overrides => {
+        const fields = { ...publicFields, ...overrides };
+        return selectFields(fields);
+      };
+      const internalMaker = overrides => {
+        const fields = { ...internalFields, ...overrides };
+        return selectFields(fields);
+      };
+
+      let sql;
+      if (typeof tableViews[viewName] === 'function') {
+        sql = tableViews[viewName](internalMaker, publicMaker);
+      } else {
+        sql = tableViews[viewName];
+      }
+      sql = sql.trim().replace(/;$/, '');
+
+      viewStrs.push(`
+        DROP VIEW IF EXISTS ${viewName};
+        CREATE VIEW ${viewName} AS ${sql};
+      `);
+    });
+  });
+
+  return viewStrs.join('\n');
+}

package/src/server/auth/app.ts

@@ -0,0 +1,387 @@
+import * as asyncStorage from '../../platform/server/asyncStorage';
+import { logger } from '../../platform/server/log';
+import type { OpenIdConfig } from '../../types/models';
+import { createApp } from '../app';
+import * as encryption from '../encryption';
+import { PostError } from '../errors';
+import { get, post } from '../post';
+import { getServer, isValidBaseURL } from '../server-config';
+
+export type AuthHandlers = {
+  'get-did-bootstrap': typeof didBootstrap;
+  'subscribe-needs-bootstrap': typeof needsBootstrap;
+  'subscribe-bootstrap': typeof bootstrap;
+  'subscribe-get-login-methods': typeof getLoginMethods;
+  'subscribe-get-user': typeof getUser;
+  'subscribe-change-password': typeof changePassword;
+  'subscribe-sign-in': typeof signIn;
+  'subscribe-sign-out': typeof signOut;
+  'subscribe-set-token': typeof setToken;
+  'enable-openid': typeof enableOpenId;
+  'get-openid-config': typeof getOpenIdConfig;
+  'enable-password': typeof enablePassword;
+};
+
+export const app = createApp<AuthHandlers>();
+app.method('get-did-bootstrap', didBootstrap);
+app.method('subscribe-needs-bootstrap', needsBootstrap);
+app.method('subscribe-bootstrap', bootstrap);
+app.method('subscribe-get-login-methods', getLoginMethods);
+app.method('subscribe-get-user', getUser);
+app.method('subscribe-change-password', changePassword);
+app.method('subscribe-sign-in', signIn);
+app.method('subscribe-sign-out', signOut);
+app.method('subscribe-set-token', setToken);
+app.method('enable-openid', enableOpenId);
+app.method('get-openid-config', getOpenIdConfig);
+app.method('enable-password', enablePassword);
+
+async function didBootstrap() {
+  return Boolean(await asyncStorage.getItem('did-bootstrap'));
+}
+
+async function needsBootstrap({ url }: { url?: string } = {}) {
+  if (url && !isValidBaseURL(url)) {
+    return { error: 'get-server-failure' };
+  }
+
+  let serverConfig: ReturnType<typeof getServer>;
+
+  try {
+    serverConfig = getServer(url);
+    if (!serverConfig) {
+      return { bootstrapped: true, hasServer: false };
+    }
+  } catch {
+    return { error: 'get-server-failure' };
+  }
+
+  let resText: string;
+  try {
+    resText = await get(serverConfig.SIGNUP_SERVER + '/needs-bootstrap');
+  } catch {
+    return { error: 'network-failure' };
+  }
+
+  let res: {
+    status: 'ok';
+    data: {
+      bootstrapped: boolean;
+      loginMethod: 'password' | 'openid' | string;
+      availableLoginMethods: Array<{
+        method: string;
+        displayName: string;
+        active: boolean;
+      }>;
+      multiuser: boolean;
+    };
+  };
+
+  try {
+    res = JSON.parse(resText);
+  } catch {
+    return { error: 'parse-failure' };
+  }
+
+  return {
+    bootstrapped: res.data.bootstrapped,
+    availableLoginMethods: res.data.availableLoginMethods || [
+      { method: 'password', active: true, displayName: 'Password' },
+    ],
+    multiuser: res.data.multiuser || false,
+    hasServer: true,
+  };
+}
+
+async function bootstrap(loginConfig: {
+  password?: string;
+  openId?: OpenIdConfig;
+}) {
+  try {
+    const serverConfig = getServer();
+    if (!serverConfig) {
+      throw new Error('No sync server configured.');
+    }
+    await post(serverConfig.SIGNUP_SERVER + '/bootstrap', loginConfig);
+  } catch (err) {
+    if (err instanceof PostError) {
+      return {
+        error: err.reason || 'network-failure',
+      };
+    }
+
+    throw err;
+  }
+  return {};
+}
+
+async function getLoginMethods() {
+  let res: {
+    methods?: Array<{ method: string; displayName: string; active: boolean }>;
+  };
+  try {
+    const serverConfig = getServer();
+    if (!serverConfig) {
+      throw new Error('No sync server configured.');
+    }
+    res = await fetch(serverConfig.SIGNUP_SERVER + '/login-methods').then(res =>
+      res.json(),
+    );
+  } catch (err) {
+    if (err instanceof PostError) {
+      return {
+        error: err.reason || 'network-failure',
+      };
+    }
+
+    throw err;
+  }
+
+  if (res.methods) {
+    return { methods: res.methods };
+  }
+  return { error: 'internal' };
+}
+
+async function getUser() {
+  const serverConfig = getServer();
+  if (!serverConfig) {
+    if (!(await asyncStorage.getItem('did-bootstrap'))) {
+      return null;
+    }
+    return { offline: false };
+  }
+
+  const userToken = await asyncStorage.getItem('user-token');
+
+  if (!userToken) {
+    return null;
+  }
+
+  try {
+    const res = await get(serverConfig.SIGNUP_SERVER + '/validate', {
+      headers: {
+        'X-ACTUAL-TOKEN': userToken,
+      },
+    });
+    let tokenExpired = false;
+    const {
+      status,
+      reason,
+      data: {
+        userName = null,
+        permission = '',
+        userId = null,
+        displayName = null,
+        loginMethod = null,
+        prefs: serverPrefs,
+      } = {},
+    } = JSON.parse(res) || {};
+
+    if (status === 'error') {
+      if (reason === 'unauthorized') {
+        return null;
+      } else if (reason === 'token-expired') {
+        tokenExpired = true;
+      } else {
+        return { offline: true };
+      }
+    }
+
+    return {
+      offline: false,
+      userName,
+      permission,
+      userId,
+      displayName,
+      loginMethod,
+      tokenExpired,
+      serverPrefs,
+    };
+  } catch (e) {
+    logger.log(e);
+    return { offline: true };
+  }
+}
+
+async function changePassword({ password }: { password: string }) {
+  const userToken = await asyncStorage.getItem('user-token');
+  if (!userToken) {
+    return { error: 'not-logged-in' };
+  }
+
+  try {
+    const serverConfig = getServer();
+    if (!serverConfig) {
+      throw new Error('No sync server configured.');
+    }
+    await post(serverConfig.SIGNUP_SERVER + '/change-password', {
+      token: userToken,
+      password,
+    });
+  } catch (err) {
+    if (err instanceof PostError) {
+      return {
+        error: err.reason || 'network-failure',
+      };
+    }
+
+    throw err;
+  }
+
+  return {};
+}
+
+async function signIn(
+  loginInfo:
+    | {
+        password: string;
+        loginMethod?: string;
+      }
+    | {
+        returnUrl: string;
+        loginMethod?: 'openid';
+      },
+) {
+  if (
+    typeof loginInfo.loginMethod !== 'string' ||
+    loginInfo.loginMethod == null
+  ) {
+    loginInfo.loginMethod = 'password';
+  }
+  let res: {
+    token?: string;
+    returnUrl?: string;
+  };
+
+  try {
+    const serverConfig = getServer();
+    if (!serverConfig) {
+      throw new Error('No sync server configured.');
+    }
+    res = await post(serverConfig.SIGNUP_SERVER + '/login', loginInfo);
+  } catch (err) {
+    if (err instanceof PostError) {
+      return {
+        error: err.reason || 'network-failure',
+      };
+    }
+
+    throw err;
+  }
+
+  if (res.returnUrl) {
+    return { redirectUrl: res.returnUrl };
+  }
+
+  if (!res.token) {
+    throw new Error('login: User token not set');
+  }
+
+  await asyncStorage.setItem('user-token', res.token);
+  return {};
+}
+
+async function signOut() {
+  encryption.unloadAllKeys();
+  await asyncStorage.multiRemove([
+    'user-token',
+    'encrypt-keys',
+    'lastBudget',
+    'readOnly',
+  ]);
+  return 'ok';
+}
+
+async function setToken({ token }: { token: string }) {
+  await asyncStorage.setItem('user-token', token);
+}
+
+async function enableOpenId(openIdConfig: { openId: OpenIdConfig }) {
+  try {
+    const userToken = await asyncStorage.getItem('user-token');
+
+    if (!userToken) {
+      return { error: 'unauthorized' };
+    }
+
+    const serverConfig = getServer();
+    if (!serverConfig) {
+      throw new Error('No sync server configured.');
+    }
+
+    await post(serverConfig.BASE_SERVER + '/openid/enable', openIdConfig, {
+      'X-ACTUAL-TOKEN': userToken,
+    });
+  } catch (err) {
+    if (err instanceof PostError) {
+      return {
+        error: err.reason || 'network-failure',
+      };
+    }
+
+    throw err;
+  }
+  return {};
+}
+
+async function getOpenIdConfig({ password }: { password: string }) {
+  try {
+    const userToken = await asyncStorage.getItem('user-token');
+
+    const serverConfig = getServer();
+    if (!serverConfig) {
+      throw new Error('No sync server configured.');
+    }
+
+    const res = await post(
+      serverConfig.BASE_SERVER + '/openid/config',
+      { password },
+      {
+        'X-ACTUAL-TOKEN': userToken,
+      },
+    );
+
+    if (res) {
+      return res as { openId: OpenIdConfig };
+    }
+
+    return null;
+  } catch (err) {
+    if (err instanceof PostError) {
+      return {
+        error: err.reason || 'network-failure',
+      };
+    }
+
+    throw err;
+  }
+}
+
+async function enablePassword(passwordConfig: { password: string }) {
+  try {
+    const userToken = await asyncStorage.getItem('user-token');
+
+    if (!userToken) {
+      return { error: 'unauthorized' };
+    }
+
+    const serverConfig = getServer();
+    if (!serverConfig) {
+      throw new Error('No sync server configured.');
+    }
+
+    await post(serverConfig.BASE_SERVER + '/openid/disable', passwordConfig, {
+      'X-ACTUAL-TOKEN': userToken,
+    });
+  } catch (err) {
+    if (err instanceof PostError) {
+      return {
+        error: err.reason || 'network-failure',
+      };
+    }
+
+    throw err;
+  }
+  return {};
+}