stellarium-ts 0.19.1 → 0.20.0

package/dist/tests/helpers.js

@@ -1,4 +1,7 @@
 import { generateKeyPairSync } from "node:crypto";
+import { PGlite } from "@electric-sql/pglite";
+import { createTables, openDatabase } from "../db/db.js";
+import { PostgresDatabase } from "../db/postgres.js";
 export function generateBase64KeyPair() {
     const { publicKey, privateKey } = generateKeyPairSync("ed25519", {
         publicKeyEncoding: { type: "spki", format: "der" },
@@ -82,3 +85,37 @@ export function modelResource(baseUrl = "http://127.0.0.1:3002") {
     };
 }
 export const temperatureSource = 'request GetTemperature {\n  const weather: com.example.Weather\n\n  return weather.temperature(city: "Oslo")\n}';
+/** Both databases a node can use. Suites that touch the database run against each. */
+export const DIALECTS = ["sqlite", "postgres"];
+export function pgliteDriver(pg) {
+    return {
+        query: async (text, params) => {
+            const result = await pg.query(text, params);
+            return { rows: result.rows, rowCount: result.affectedRows ?? 0 };
+        },
+        exec: async (text) => {
+            await pg.exec(text);
+        },
+        transaction: (work) => {
+            if (!("transaction" in pg)) {
+                throw new Error("Transactions cannot be nested");
+            }
+            return pg.transaction(tx => work(pgliteDriver(tx)));
+        },
+        close: async () => {
+            if ("close" in pg) {
+                await pg.close();
+            }
+        },
+    };
+}
+/** An empty node database: SQLite in memory, or Postgres in memory through PGlite. */
+export async function openTestDatabase(dialect = "sqlite") {
+    if (dialect === "sqlite") {
+        return openDatabase(":memory:");
+    }
+    // 64-bit integers come back as numbers, as node-postgres is configured to return them.
+    const db = await PostgresDatabase.open(pgliteDriver(new PGlite({ parsers: { 20: Number } })));
+    await createTables(db);
+    return db;
+}

package/dist/tests/integration/network.test.js

@@ -5,7 +5,7 @@ import path from "node:path";
 import Fastify from "fastify";
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { verifyData } from "../../crypto/utils.js";
-import { paymentVoucherPayload } from "../../resource/invoker.js";
+import { contractVoucherPayload, paymentVoucherPayload } from "../../resource/invoker.js";
 import { StellariumNode } from "../../server.js";
 import { COST, generateBase64KeyPair, INFERENCE_RATES, modelResource, ORGANIZATION, temperatureSource, weatherResource } from "../helpers.js";
 /** A free function only callers with a grant from the provider may run. */
@@ -22,6 +22,8 @@ function vaultResource(baseUrl) {
 const vaultSource = 'request OpenVault {\n  const vault: com.example.Vault\n\n  return vault.open(city: "Oslo")\n}';
 const vault = { resourcePath: "com.example", resourceName: "Vault" };
 const HOUR = 3_600_000;
+const CONTRACT_PRICE = 1_000;
+const forecastContract = 'contract com.example.Forecast(city: string): string {\n  const weather: com.example.Weather\n  const temperature = weather.temperature(city: city)\n  return "${temperature.value} degrees"\n}';
 const completeSource = 'request Complete {\n  const model: com.example.Model\n\n  return model.complete(prompt: "Hello world!", maxTokens: 10)\n}';
 function freePort() {
     return new Promise((resolve, reject) => {
@@ -45,8 +47,12 @@ describe("two-node network", { timeout: 15_000 }, () => {
     const authorizations = [];
     const releases = [];
     const sessions = [];
+    const contractAuthorizations = [];
+    const runCaptures = [];
     /** What the fake operator answers to the next authorizations; undefined places the hold. */
     let refuseAuthorization;
+    /** The provider's price, as its organization set it on the dashboard. */
+    let price = CONTRACT_PRICE;
     const callerKeys = generateBase64KeyPair();
     let dir;
     let operatorUrl;
@@ -84,7 +90,10 @@ describe("two-node network", { timeout: 15_000 }, () => {
         authorizations.length = 0;
         releases.length = 0;
         sessions.length = 0;
+        contractAuthorizations.length = 0;
+        runCaptures.length = 0;
         refuseAuthorization = undefined;
+        price = CONTRACT_PRICE;
         const operator = Fastify();
         servers.push(operator);
         operator.post("/v1/nodes/session", async (request, reply) => {
@@ -92,7 +101,15 @@ describe("two-node network", { timeout: 15_000 }, () => {
                 return reply.status(401).send({ error: "Unsigned request" });
             }
             sessions.push(request.body);
-            return { organizationId: ORGANIZATION };
+            return { organizationId: ORGANIZATION, priceMicroUsdPerMillionTokens: price };
+        });
+        operator.post("/v1/runs/contract/authorize", async (request) => {
+            contractAuthorizations.push(request.body);
+            return { status: "held", heldMicroUsd: 50_000, maxTokens: 100, tokenBudgetMicroUsd: 1, payerOrganizationId: "org_caller" };
+        });
+        operator.post("/v1/runs/capture", async (request) => {
+            runCaptures.push(request.body);
+            return { status: "captured" };
         });
         operator.post("/v1/payments/authorize", async (request, reply) => {
             authorizations.push(request.body);
@@ -123,6 +140,7 @@ describe("two-node network", { timeout: 15_000 }, () => {
             operatorUrl,
             databasePath: ":memory:",
             apiKey: "provider-admin",
+            sessionRefreshIntervalMs: 50,
             approveGrant: ({ details }) => details?.invite === "letmein" ? { lifetimeMs: HOUR } : undefined,
         });
     });
@@ -154,6 +172,56 @@ describe("two-node network", { timeout: 15_000 }, () => {
         const second = await startCaller();
         expect(await run(second.url)).toEqual({ usage: { tokens: expect.any(Number) }, returnValue: { value: 12, error: null } });
     });
+    test("the provider's contract reaches the caller, which pays for it and for the paid call it makes", async () => {
+        const caller = await startCaller();
+        const deployed = await fetch(`${providerUrl}/v1/contracts`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Authorization: "Bearer provider-admin" },
+            body: JSON.stringify({ source: forecastContract }),
+        });
+        expect(deployed.status).toBe(201);
+        // The provider announces its resources again when a contract is deployed.
+        await vi.waitFor(async () => expect((await getJson(`${caller.url}/v1/resources`)).resources).toContainEqual(expect.objectContaining({
+            name: "Forecast",
+            baseUrl: providerUrl,
+            functions: [expect.objectContaining({ name: "run", kind: "contract", paymentManifest: { priceMicroUsdPerMillionTokens: CONTRACT_PRICE, recipientOrganizationId: ORGANIZATION } })],
+        })));
+        const result = await run(caller.url, 'request R {\n  const forecast: com.example.Forecast\n  return forecast.run(city: "Oslo")\n}');
+        expect(result.returnValue).toEqual({ value: "12 degrees", error: null });
+        const [{ voucher, source }] = contractAuthorizations;
+        expect(source).toBe(forecastContract);
+        expect(voucher).toMatchObject({ kind: "contract", publicKey: callerKeys.publicKey, recipientOrganizationId: ORGANIZATION, priceMicroUsdPerMillionTokens: CONTRACT_PRICE });
+        expect(verifyData(contractVoucherPayload(voucher), voucher.publicKey, voucher.signature)).toBe(true);
+        // The contract's run pays for its tokens and for its call to the provider's paid function.
+        await vi.waitFor(() => expect(runCaptures).toEqual([{ runId: voucher.invocationId, tokens: expect.any(Number) }]));
+        await vi.waitFor(() => expect(settlements).toHaveLength(1));
+        expect(settlements[0]).toMatchObject({ amount: COST, recipientOrganizationId: ORGANIZATION, runId: voucher.invocationId });
+    });
+    test("a contract keeps state for the organization paying for a remote call", async () => {
+        const caller = await startCaller();
+        await fetch(`${providerUrl}/v1/contracts`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Authorization: "Bearer provider-admin" },
+            body: JSON.stringify({ source: "contract com.example.Visits: object {\n  var state(caller.org) visits: int32 = 0\n  visits = visits + 1\n  return { visits: visits, by: caller }\n}" }),
+        });
+        await vi.waitFor(async () => expect((await getJson(`${caller.url}/v1/resources`)).resources.map((resource) => resource.name)).toContain("Visits"));
+        const visit = 'request R {\n  const visits: com.example.Visits\n  return visits.run().value\n}';
+        expect((await run(caller.url, visit)).returnValue).toEqual({ visits: 1, by: { org: "org_caller", node: callerKeys.publicKey } });
+        expect((await run(caller.url, visit)).returnValue).toMatchObject({ visits: 2 });
+    });
+    test("the provider learns a new price from the operator, and tells peers its contracts' new price", async () => {
+        const caller = await startCaller();
+        await fetch(`${providerUrl}/v1/contracts`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Authorization: "Bearer provider-admin" },
+            body: JSON.stringify({ source: forecastContract }),
+        });
+        price = 2 * CONTRACT_PRICE;
+        await vi.waitFor(async () => {
+            const forecast = (await getJson(`${caller.url}/v1/resources`)).resources.find((resource) => resource.name === "Forecast");
+            expect(forecast?.functions[0].paymentManifest.priceMicroUsdPerMillionTokens).toBe(2 * CONTRACT_PRICE);
+        });
+    });
     describe("restricted functions", () => {
         test("the caller needs a grant from the provider, then calls with it", async () => {
             const caller = await startCaller();
@@ -223,10 +291,12 @@ describe("two-node network", { timeout: 15_000 }, () => {
     test("a caller with an enrollment token enrolls at startup; one without still reports its URL", async () => {
         sessions.length = 0;
         const enrolled = await startCaller({ operatorUrl, enrollmentToken: "enr_caller" });
-        expect(sessions).toEqual([{ enrollmentToken: "enr_caller", baseUrl: enrolled.url }]);
+        // The provider refreshes its own session meanwhile.
+        const callerSessions = () => sessions.filter(session => session.baseUrl !== providerUrl);
+        expect(callerSessions()).toEqual([{ enrollmentToken: "enr_caller", baseUrl: enrolled.url }]);
         sessions.length = 0;
         const other = await startCaller({ operatorUrl, databasePath: path.join(dir, "caller-2.db") });
-        await vi.waitFor(() => expect(sessions).toEqual([{ baseUrl: other.url }]));
+        await vi.waitFor(() => expect(callerSessions()).toEqual([{ baseUrl: other.url }]));
     });
     test("a node without paid functions or a token starts without waiting for an unreachable operator", async () => {
         const caller = await startCaller({ operatorUrl: "http://127.0.0.1:1/v1", databasePath: path.join(dir, "caller-3.db") });

package/dist/tests/peer/repository.test.js

@@ -1,16 +1,15 @@
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
 import { signData } from "../../crypto/utils.js";
-import { openDatabase } from "../../db/db.js";
 import { PeerRepository, peerAnnouncementPayload } from "../../peer/repository.js";
-import { generateBase64KeyPair } from "../helpers.js";
-describe("PeerRepository", () => {
+import { DIALECTS, generateBase64KeyPair, openTestDatabase } from "../helpers.js";
+describe.each(DIALECTS)("PeerRepository (%s)", (dialect) => {
     const keys = generateBase64KeyPair();
     const peer = { baseUrl: "http://peer.example", name: "peer", publicKey: keys.publicKey };
     const expiry = () => new Date(Date.now() + 60_000).toISOString();
     let db;
     let repository;
     beforeEach(async () => {
-        db = await openDatabase(":memory:");
+        db = await openTestDatabase(dialect);
         repository = new PeerRepository(db);
     });
     afterEach(async () => {

package/dist/tests/resource/repository.test.js

@@ -1,9 +1,8 @@
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
 import { signData } from "../../crypto/utils.js";
-import { openDatabase } from "../../db/db.js";
 import { PeerRepository } from "../../peer/repository.js";
 import { resourceAnnouncementPayload, ResourceRepository } from "../../resource/repository.js";
-import { generateBase64KeyPair, ORGANIZATION, weatherResource } from "../helpers.js";
+import { DIALECTS, generateBase64KeyPair, ORGANIZATION, weatherResource, openTestDatabase } from "../helpers.js";
 const SELF = "http://self.example";
 const PROVIDER = "http://provider.example";
 function resource(name, functions, baseUrl = PROVIDER) {
@@ -16,11 +15,11 @@ function resource(name, functions, baseUrl = PROVIDER) {
         functions: functions.map(fn => ({ name: "fn", parameters: [], returnType: "string", exec: async () => undefined, ...fn })),
     };
 }
-describe("ResourceRepository", () => {
+describe.each(DIALECTS)("ResourceRepository (%s)", (dialect) => {
     let db;
     let repository;
     beforeEach(async () => {
-        db = await openDatabase(":memory:");
+        db = await openTestDatabase(dialect);
         repository = new ResourceRepository(db, [weatherResource(SELF)], SELF);
     });
     afterEach(async () => {

package/dist/tests/routes.test.js

@@ -3,7 +3,6 @@ import Fastify from "fastify";
 import { createLocalJWKSet, exportJWK, SignJWT } from "jose";
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { safeVerifyData, signData } from "../crypto/utils.js";
-import { openDatabase } from "../db/db.js";
 import { grantRenewalPayload, grantRequestPayload } from "../grant/grant.js";
 import { GrantRepository } from "../grant/repository.js";
 import { GrantService } from "../grant/service.js";
@@ -12,10 +11,10 @@ import { CombinationResourceInvoker, inferenceVoucherPayload, paymentVoucherPayl
 import { resourceAnnouncementPayload } from "../resource/repository.js";
 import routes from "../routes.js";
 import { createService } from "../service.js";
-import { COST, generateBase64KeyPair, INFERENCE_RATES, modelResource, ORGANIZATION, temperatureSource, testConfig, weatherResource } from "./helpers.js";
+import { DIALECTS, COST, generateBase64KeyPair, INFERENCE_RATES, modelResource, ORGANIZATION, temperatureSource, testConfig, weatherResource, openTestDatabase } from "./helpers.js";
 const parameters = [{ name: "city", value: "Oslo" }];
 const inMinutes = (minutes) => new Date(Date.now() + minutes * 60_000).toISOString();
-describe("routes", () => {
+describe.each(DIALECTS)("routes (%s)", (dialect) => {
     const weather = weatherResource();
     const caller = generateBase64KeyPair();
     // Signs vouchers as a remote caller would. Its local branch never touches the repository.
@@ -28,7 +27,7 @@ describe("routes", () => {
     let capture;
     let release;
     beforeEach(async () => {
-        db = await openDatabase(":memory:");
+        db = await openTestDatabase(dialect);
         config = testConfig();
         service = createService(db, [weather], config);
         authorize = vi.spyOn(service.operatorClient, "authorize").mockResolvedValue({ ok: true });
@@ -490,7 +489,7 @@ describe("routes", () => {
         });
     });
 });
-describe("restricted functions", () => {
+describe.each(DIALECTS)("restricted functions (%s)", (dialect) => {
     const caller = generateBase64KeyPair();
     const callerInvoker = new CombinationResourceInvoker(undefined, 100_000, caller.publicKey, caller.privateKey);
     const restricted = {
@@ -512,12 +511,12 @@ describe("restricted functions", () => {
     let fastify;
     let grant;
     beforeEach(async () => {
-        db = await openDatabase(":memory:");
+        db = await openTestDatabase(dialect);
         service = createService(db, [restricted], testConfig());
         vi.spyOn(service.operatorClient, "authorize").mockResolvedValue({ ok: true });
         vi.spyOn(service.operatorClient, "capture").mockResolvedValue(undefined);
         vi.spyOn(service.operatorClient, "release").mockResolvedValue(undefined);
-        callerDb = await openDatabase(":memory:");
+        callerDb = await openTestDatabase(dialect);
         callerGrants = new GrantService(new GrantRepository(callerDb), { baseUrl: "http://caller", ...caller });
         grant = await service.grantService.issue(caller.publicKey, [{ resourcePath: "com.example", resourceName: "Vault" }], { lifetimeMs: 3_600_000 });
         fastify = Fastify();
@@ -553,7 +552,7 @@ describe("restricted functions", () => {
         beforeEach(async () => {
             await fastify.close();
             await db.close();
-            db = await openDatabase(":memory:");
+            db = await openTestDatabase(dialect);
             service = createService(db, [restricted], testConfig(), {
                 approveGrant: ({ details }) => details?.invite === "letmein" ? { lifetimeMs: 3_600_000 } : undefined,
             });
@@ -587,7 +586,7 @@ describe("restricted functions", () => {
         test("answers 500 when the approval hook returns an invalid approval", async () => {
             await fastify.close();
             await db.close();
-            db = await openDatabase(":memory:");
+            db = await openTestDatabase(dialect);
             service = createService(db, [restricted], testConfig(), { approveGrant: () => ({ lifetimeMs: -1 }) });
             fastify = Fastify();
             await fastify.register(routes, { prefix: "/v1", service });
@@ -700,7 +699,7 @@ describe("restricted functions", () => {
         });
     });
 });
-describe("inference functions", () => {
+describe.each(DIALECTS)("inference functions (%s)", (dialect) => {
     const weather = weatherResource();
     const model = modelResource();
     const caller = generateBase64KeyPair();
@@ -716,7 +715,7 @@ describe("inference functions", () => {
     let capture;
     let release;
     beforeEach(async () => {
-        db = await openDatabase(":memory:");
+        db = await openTestDatabase(dialect);
         service = createService(db, [weather, model], testConfig());
         authorize = vi.spyOn(service.operatorClient, "authorize").mockResolvedValue({ ok: true });
         capture = vi.spyOn(service.operatorClient, "capture").mockResolvedValue(undefined);

package/dist/tests/server.test.js

@@ -33,6 +33,28 @@ describe("resolveConfig", () => {
         expect(resolveConfig(keys).databasePath).toBe("/data/requestscript.db");
         expect(resolveConfig({ ...keys, databasePath: ":memory:" }).databasePath).toBe(":memory:");
     });
+    test("uses Postgres when DATABASE_URL is set, in DATABASE_SCHEMA", () => {
+        vi.stubEnv("DATABASE_PATH", undefined);
+        vi.stubEnv("DATABASE_URL", "postgresql://node@db/stellarium");
+        vi.stubEnv("DATABASE_SCHEMA", "node_a");
+        const config = resolveConfig(keys);
+        expect(config).toMatchObject({ databaseUrl: "postgresql://node@db/stellarium", databaseSchema: "node_a" });
+        expect(config.databasePath).toBeUndefined();
+        vi.stubEnv("DATABASE_URL", "");
+        vi.stubEnv("DATABASE_SCHEMA", "");
+        expect(resolveConfig(keys).databasePath).toBe(DEFAULT_DATABASE_PATH);
+        expect(resolveConfig(keys).databaseUrl).toBeUndefined();
+    });
+    test("refuses a database configuration it can't use", () => {
+        vi.stubEnv("DATABASE_PATH", undefined);
+        vi.stubEnv("DATABASE_URL", undefined);
+        vi.stubEnv("DATABASE_SCHEMA", undefined);
+        const url = "postgres://db/stellarium";
+        expect(() => resolveConfig({ ...keys, databaseUrl: "mysql://db/stellarium" })).toThrow("postgres://");
+        expect(() => resolveConfig({ ...keys, databaseUrl: url, databasePath: "./node.db" })).toThrow("not both");
+        expect(() => resolveConfig({ ...keys, databaseSchema: "node_a" })).toThrow("needs a Postgres");
+        expect(() => resolveConfig({ ...keys, databaseUrl: url, databaseSchema: "Node-A" })).toThrow("Invalid database schema");
+    });
     test("requires the signing keys and base URL", () => {
         vi.stubEnv("SIGNING_PRIVATE_KEY", undefined);
         expect(() => resolveConfig({ baseUrl: keys.baseUrl, publicKey: keys.publicKey })).toThrow("SIGNING_PRIVATE_KEY is required");

package/dist/tests/startup.test.js

@@ -1,13 +1,12 @@
 import Fastify from "fastify";
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import { openDatabase } from "../db/db.js";
 import routes from "../routes.js";
 import { createService } from "../service.js";
 import { STARTUP_PAGE_SIZE, StartupService } from "../startup.js";
-import { testConfig, weatherResource } from "./helpers.js";
+import { DIALECTS, testConfig, weatherResource, openTestDatabase } from "./helpers.js";
 const STARTING_PEER = "http://starting.example";
 const SELF = "http://self.example";
-describe("StartupService", () => {
+describe.each(DIALECTS)("StartupService (%s)", (dialect) => {
     const peerCount = STARTUP_PAGE_SIZE * 2 + 5;
     const resourceCount = STARTUP_PAGE_SIZE + 1;
     let databases;
@@ -16,7 +15,7 @@ describe("StartupService", () => {
     let startup;
     let requestedUrls;
     beforeEach(async () => {
-        const startingDb = await openDatabase(":memory:");
+        const startingDb = await openTestDatabase(dialect);
         const startingService = createService(startingDb, [weatherResource(STARTING_PEER)], testConfig({ baseUrl: STARTING_PEER }));
         for (let i = 0; i < peerCount; i++) {
             const baseUrl = `http://peer${i}.example`;
@@ -36,7 +35,7 @@ describe("StartupService", () => {
             const response = await startingNode.inject({ method: "GET", url: url.pathname + url.search });
             return new Response(response.body, { status: response.statusCode, headers: { "Content-Type": "application/json" } });
         });
-        const db = await openDatabase(":memory:");
+        const db = await openTestDatabase(dialect);
         databases = [startingDb, db];
         const config = testConfig({ baseUrl: SELF });
         service = createService(db, [], config);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stellarium-ts",
-  "version": "0.19.1",
+  "version": "0.20.0",
   "description": "A Stellarium Node in TypeScript.",
   "homepage": "https://github.com/qualletio/stellarium-ts#readme",
   "bugs": {
@@ -35,7 +35,9 @@
   "license": "ISC",
   "devDependencies": {
     "@biomejs/biome": "^2.5.15",
+    "@electric-sql/pglite": "^0.5.10",
     "@types/node": "^26.6.4",
+    "@types/pg": "^8.23.1",
     "turbo": "^2.11.7",
     "typescript": "^7.0.2",
     "vite": "^8.3.3",
@@ -46,7 +48,8 @@
     "dotenv": "^18.0.5",
     "fastify": "^5.12.5",
     "jose": "6.1.0",
-    "requestscript": "1.3.0",
+    "pg": "^8.23.1",
+    "requestscript": "1.5.0",
     "sqlite": "^5.1.1",
     "sqlite3": "^6.0.1"
   },