mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-11-20 02:56:10 +00:00
910c98b971
PLUGIN_DATA binds the plugin data backend to the engine (the same
{ sqlite, postgres }[engine.id] binding the backup port uses): the SQLite
file per plugin, unchanged, or the Postgres schema per plugin. The host
opens a plugin's store through it and an uninstall that deletes data erases
through it, which drops the schema on Postgres. Nothing outside db/engine
asks which engine runs.
A plugin's SQL is passed through as written, so a plugin needs to know the
dialect: db.engine (db:own) answers 'sqlite' or 'postgres', and the SDK
exposes it as ctx.db.engine(), in the mock host (dbEngine option) and in
dev. The plugin facts are regenerated and the SDK goes to 1.10.0.
The Postgres lane's PGPLUG suite installs, uses and erases plugin data on
Postgres and shows that a plugin reaches neither TREK's users table nor
another plugin's schema.
105 lines
4.5 KiB
TypeScript
105 lines
4.5 KiB
TypeScript
/**
|
|
* The plugin data port (src/nest/plugins/host/plugin-data.backend.ts): the
|
|
* backend `PLUGIN_DATA` binds is the engine's, the SQLite one keeps a file per
|
|
* plugin, and the Postgres one opens a schema store and writes no SQLite file.
|
|
* The Postgres store against a real database is the Postgres lane's
|
|
* tests/postgres/plugin-data.test.ts.
|
|
*/
|
|
import type { DbSettings } from '../../../src/app-config';
|
|
import type { DatabaseEngine } from '../../../src/db/engine';
|
|
import { PostgresPluginDataStore } from '../../../src/db/engine/postgres/plugin-data-store';
|
|
import {
|
|
PLUGIN_DATA,
|
|
PLUGIN_DATA_PROVIDERS,
|
|
PostgresPluginDataBackend,
|
|
SqlitePluginDataBackend,
|
|
} from '../../../src/nest/plugins/host/plugin-data.backend';
|
|
import { PluginDataDb } from '../../../src/nest/plugins/host/plugin-data.service';
|
|
import type { MikroORM } from '@mikro-orm/core';
|
|
import type { FactoryProvider } from '@nestjs/common';
|
|
|
|
import fs from 'node:fs';
|
|
import os from 'node:os';
|
|
import path from 'node:path';
|
|
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
|
|
|
|
let tmp: string;
|
|
beforeAll(() => {
|
|
tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'trek-plugin-data-port-'));
|
|
process.env.TREK_PLUGINS_DATA_DIR = tmp;
|
|
});
|
|
afterAll(() => {
|
|
delete process.env.TREK_PLUGINS_DATA_DIR;
|
|
fs.rmSync(tmp, { recursive: true, force: true });
|
|
});
|
|
|
|
/** An ORM whose Kysely client records the SQL it is handed. */
|
|
function fakeOrm(executed: string[]): MikroORM {
|
|
const client = {
|
|
executeQuery: async (query: { sql: string }) => {
|
|
executed.push(query.sql);
|
|
return { rows: [] };
|
|
},
|
|
};
|
|
return { em: { getConnection: () => ({ getClient: () => client }) } } as unknown as MikroORM;
|
|
}
|
|
|
|
const POSTGRES = { engine: 'postgres', url: 'postgres://trek@db/trek', poolMax: 4 } as unknown as DbSettings;
|
|
const SQLITE = { engine: 'sqlite' } as unknown as DbSettings;
|
|
|
|
describe('plugin data port', () => {
|
|
it('PLUGDATA-001: PLUGIN_DATA is the backend of the engine TREK runs on', () => {
|
|
const binding = PLUGIN_DATA_PROVIDERS.find(
|
|
(p): p is FactoryProvider => typeof p === 'object' && 'provide' in p && p.provide === PLUGIN_DATA,
|
|
);
|
|
expect(binding).toBeDefined();
|
|
const sqlite = new SqlitePluginDataBackend();
|
|
const postgres = new PostgresPluginDataBackend(fakeOrm([]), POSTGRES);
|
|
const pick = (id: 'sqlite' | 'postgres') => binding?.useFactory({ id } as DatabaseEngine, sqlite, postgres);
|
|
expect(pick('sqlite')).toBe(sqlite);
|
|
expect(pick('postgres')).toBe(postgres);
|
|
expect(sqlite.engine).toBe('sqlite');
|
|
expect(postgres.engine).toBe('postgres');
|
|
});
|
|
|
|
it("PLUGDATA-002: on SQLite a plugin's data is a file of its own, and erasing removes its directory", async () => {
|
|
const backend = new SqlitePluginDataBackend();
|
|
const store = backend.open('sqlite-one');
|
|
expect(store).toBeInstanceOf(PluginDataDb);
|
|
expect(store.engine).toBe('sqlite');
|
|
store.close();
|
|
expect(fs.existsSync(path.join(tmp, 'sqlite-one', 'plugin.db'))).toBe(true);
|
|
await backend.erase('sqlite-one');
|
|
expect(fs.existsSync(path.join(tmp, 'sqlite-one'))).toBe(false);
|
|
});
|
|
|
|
it('PLUGDATA-003: on Postgres a plugin gets a schema store and its data directory, but no SQLite file', async () => {
|
|
const executed: string[] = [];
|
|
const backend = new PostgresPluginDataBackend(fakeOrm(executed), POSTGRES);
|
|
const store = backend.open('pg-one');
|
|
expect(store).toBeInstanceOf(PostgresPluginDataStore);
|
|
expect(store.engine).toBe('postgres');
|
|
expect(fs.readdirSync(path.join(tmp, 'pg-one'))).toEqual([]);
|
|
expect(executed).toEqual([]);
|
|
|
|
await backend.erase('pg-one');
|
|
expect(executed).toEqual(['drop schema if exists "trek_plugin_pg_one" cascade']);
|
|
expect(fs.existsSync(path.join(tmp, 'pg-one'))).toBe(false);
|
|
});
|
|
|
|
it('PLUGDATA-004: the Postgres backend refuses to open a store without a Postgres database', () => {
|
|
const backend = new PostgresPluginDataBackend(fakeOrm([]), SQLITE);
|
|
expect(() => backend.open('pg-two')).toThrow(/without TREK_DB_URL/);
|
|
});
|
|
|
|
it('PLUGDATA-005: a closed Postgres store refuses new calls, so the host opens a fresh one', async () => {
|
|
const backend = new PostgresPluginDataBackend(fakeOrm([]), POSTGRES);
|
|
const store = backend.open('pg-three');
|
|
expect(store.isOpen()).toBe(true);
|
|
store.close();
|
|
expect(store.isOpen()).toBe(false);
|
|
await expect(store.query('SELECT 1')).rejects.toThrow('The database connection is not open');
|
|
await expect(store.query('SELECT * FROM public.users')).rejects.toThrow('The database connection is not open');
|
|
});
|
|
});
|