stellarium-ts 0.1.0

package/README.md

@@ -0,0 +1,3 @@
+# stellarium-ts
+
+Typescript implementation of a Stellarium node

package/dist/db/db.d.ts

@@ -0,0 +1,5 @@
+import sqlite3 from 'sqlite3';
+declare const db: import("sqlite").Database<sqlite3.Database, sqlite3.Statement>;
+export declare function createTables(): Promise<void>;
+export default db;
+//# sourceMappingURL=db.d.ts.map

package/dist/db/db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/db/db.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,SAAS,CAAC;AAG9B,QAAA,MAAM,EAAE,gEAGN,CAAC;AAIH,wBAAsB,YAAY,kBA2CjC;eAGc,EAAE"}

package/dist/db/db.js

@@ -0,0 +1,52 @@
+import sqlite3 from 'sqlite3';
+import { open } from 'sqlite';
+const db = await open({
+    filename: './requestscript.db', // Specify the database file
+    driver: sqlite3.Database,
+});
+// Create tables
+export async function createTables() {
+    await db.exec(`
+        CREATE TABLE IF NOT EXISTS peer (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            base_url TEXT NOT NULL,
+            name TEXT NOT NULL,
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL,
+
+            UNIQUE (base_url)
+            UNIQUE (name)
+        );
+
+        CREATE TABLE IF NOT EXISTS resources (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            path TEXT NOT NULL,
+            name TEXT NOT NULL,
+            base_url TEXT NOT NULL,
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL,
+
+            UNIQUE (path, name)
+            UNIQUE (base_url)
+        );
+
+        CREATE TABLE IF NOT EXISTS resource_functions (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            resource_id INTEGER NOT NULL,
+            name TEXT NOT NULL,
+            return_type TEXT NOT NULL,
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS resource_function_parameters (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            resource_function_id INTEGER NOT NULL,
+            name TEXT NOT NULL,
+            parameter_type TEXT NOT NULL,
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL
+        );
+    `);
+}
+export default db;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { StellariumNode, type StellariumNodeOptions } from './server.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,qBAAqB,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+export { StellariumNode } from './server.js';

package/dist/peer/repository.d.ts

@@ -0,0 +1,13 @@
+import { Database } from "sqlite";
+export interface Peer {
+    baseUrl: string;
+    name: string;
+}
+export declare class PeerRepository {
+    private readonly db;
+    constructor(db: Database);
+    create(peer: Peer): Promise<void>;
+    deleteAll(): Promise<void>;
+    getPeerList(): Promise<Peer[]>;
+}
+//# sourceMappingURL=repository.d.ts.map

package/dist/peer/repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../src/peer/repository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAElC,MAAM,WAAW,IAAI;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,cAAc;IACX,OAAO,CAAC,QAAQ,CAAC,EAAE;IAA/B,YAA6B,EAAE,EAAE,QAAQ,EAAI;IAEvC,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAiBtC;IAEK,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAE/B;IAEK,WAAW,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC,CAMnC;CACJ"}

package/dist/peer/repository.js

@@ -0,0 +1,25 @@
+export class PeerRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async create(peer) {
+        // Check if the peer already exists
+        const existingPeer = await this.db.get('SELECT * FROM peer WHERE base_url = ?', [peer.baseUrl, peer.name]);
+        if (existingPeer) {
+            return;
+        }
+        const createdAt = new Date().toISOString();
+        await this.db.run('INSERT INTO peer (base_url, name, created_at, updated_at) VALUES (?, ?, ?, ?)', [peer.baseUrl, peer.name, createdAt, createdAt]);
+    }
+    async deleteAll() {
+        await this.db.run('DELETE FROM peer');
+    }
+    async getPeerList() {
+        const results = await this.db.all('SELECT * FROM peer');
+        return results.map(result => ({
+            baseUrl: result.base_url,
+            name: result.name,
+        }));
+    }
+}

package/dist/resource/invoker.d.ts

@@ -0,0 +1,15 @@
+import { Resource, ResourceFunctionCallParameter, ResourceInvoker } from "requestscript";
+export declare class CombinationResourceInvoker implements ResourceInvoker {
+    /**
+     * Invoke a function on a resource.
+     * If the resource has a baseUrl, it will be invoked as a remote function.
+     * Otherwise, it will be invoked as a local function.
+     *
+     * @param resource - The resource to invoke
+     * @param functionName - The name of the function to invoke
+     * @param parameters - The parameters to pass to the function
+     * @returns The return value of the function
+     */
+    invoke(resource: Resource, functionName: string, parameters: ResourceFunctionCallParameter[]): Promise<any>;
+}
+//# sourceMappingURL=invoker.d.ts.map

package/dist/resource/invoker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invoker.d.ts","sourceRoot":"","sources":["../../src/resource/invoker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,6BAA6B,EAA6B,eAAe,EAAE,MAAM,eAAe,CAAC;AAEpH,qBAAa,0BAA2B,YAAW,eAAe;IAE9D;;;;;;;;;OASG;IACG,MAAM,CAAC,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,6BAA6B,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,CAoChH;CACJ"}

package/dist/resource/invoker.js

@@ -0,0 +1,43 @@
+export class CombinationResourceInvoker {
+    /**
+     * Invoke a function on a resource.
+     * If the resource has a baseUrl, it will be invoked as a remote function.
+     * Otherwise, it will be invoked as a local function.
+     *
+     * @param resource - The resource to invoke
+     * @param functionName - The name of the function to invoke
+     * @param parameters - The parameters to pass to the function
+     * @returns The return value of the function
+     */
+    async invoke(resource, functionName, parameters) {
+        if (resource.metadata.baseUrl) {
+            const query = `
+            request Invoke${resource.name}${functionName} {
+                const ${resource.name.toLowerCase()} = ${resource.path}.${resource.name}
+
+                return ${resource.name.toLowerCase()}.${functionName}(${parameters.map(p => `${p.name}: ${p.value}`).join(', ')})
+            }`;
+            console.log(query);
+            const url = resource.metadata.baseUrl;
+            if (!url) {
+                throw new Error(`Resource ${resource.name} does not have a url`);
+            }
+            const result = await fetch(`${url}/run`, {
+                method: 'POST',
+                body: query,
+            });
+            if (!result.ok) {
+                throw new Error(`Failed to invoke ${resource.name}.${functionName}: ${result.statusText}`);
+            }
+            const data = await result.json();
+            return data.returnValue;
+        }
+        else {
+            const fn = resource.functions.find(f => f.name === functionName);
+            if (!fn) {
+                throw new Error(`Function ${functionName} not found in resource ${resource.name}`);
+            }
+            return await fn.exec(parameters);
+        }
+    }
+}

package/dist/resource/resolver.d.ts

@@ -0,0 +1,14 @@
+import { Resource, ResourceResolver } from "requestscript";
+import { ResourceRepository } from "./resource.js";
+/**
+ * CombinationResourceResolver is a resource resolver that combines multiple resource resolvers.
+ * It will first try to resolve the resource from the resource repository.
+ * If the resource is not found, it will try to resolve the resource from the external resource resolvers.
+ * If the resource is not found, it will return undefined.
+ */
+export declare class CombinationResourceResolver implements ResourceResolver {
+    private readonly resourceRepository;
+    constructor(resourceRepository: ResourceRepository);
+    resolve(key: string): Promise<Resource | undefined>;
+}
+//# sourceMappingURL=resolver.d.ts.map

package/dist/resource/resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../src/resource/resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAEnD;;;;;GAKG;AACH,qBAAa,2BAA4B,YAAW,gBAAgB;IACpD,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IAA/C,YAA6B,kBAAkB,EAAE,kBAAkB,EAAI;IAEjE,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,CAExD;CACJ"}

package/dist/resource/resolver.js

@@ -0,0 +1,15 @@
+/**
+ * CombinationResourceResolver is a resource resolver that combines multiple resource resolvers.
+ * It will first try to resolve the resource from the resource repository.
+ * If the resource is not found, it will try to resolve the resource from the external resource resolvers.
+ * If the resource is not found, it will return undefined.
+ */
+export class CombinationResourceResolver {
+    resourceRepository;
+    constructor(resourceRepository) {
+        this.resourceRepository = resourceRepository;
+    }
+    async resolve(key) {
+        return await this.resourceRepository.getResource(key);
+    }
+}

package/dist/resource/resource.d.ts

@@ -0,0 +1,16 @@
+import { Resource, ResourceFunctionParameter } from "requestscript";
+import { Database } from "sqlite";
+export interface ResourceWithBaseUrl extends Resource {
+    baseUrl: string;
+}
+export declare class ResourceRepository {
+    private readonly db;
+    private resources;
+    constructor(db: Database, resources?: Resource[]);
+    create(resource: Resource, baseUrl: string): Promise<void>;
+    getResource(key: string): Promise<Resource | undefined>;
+    getExternalResources(): Promise<Resource[]>;
+    getResourceParameters(resourceFunctionId: number): Promise<ResourceFunctionParameter[]>;
+    getAllResources(): Promise<ResourceWithBaseUrl[]>;
+}
+//# sourceMappingURL=resource.d.ts.map

package/dist/resource/resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../../src/resource/resource.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAElC,MAAM,WAAW,mBAAoB,SAAQ,QAAQ;IACjD,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,kBAAkB;IACf,OAAO,CAAC,QAAQ,CAAC,EAAE;IAAY,OAAO,CAAC,SAAS;IAA5D,YAA6B,EAAE,EAAE,QAAQ,EAAU,SAAS,GAAE,QAAQ,EAAO,EAAI;IAE3E,MAAM,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAM/D;IAEK,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,CAyC5D;IAEK,oBAAoB,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC,CAqBhD;IAEK,qBAAqB,CAAC,kBAAkB,EAAE,MAAM,GAAG,OAAO,CAAC,yBAAyB,EAAE,CAAC,CAK5F;IAEK,eAAe,IAAI,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAWtD;CACJ"}

package/dist/resource/resource.js

@@ -0,0 +1,78 @@
+export class ResourceRepository {
+    db;
+    resources;
+    constructor(db, resources = []) {
+        this.db = db;
+        this.resources = resources;
+    }
+    async create(resource, baseUrl) {
+        const createdAt = new Date().toISOString();
+        await this.db.run('INSERT INTO resources (path, name, base_url, created_at, updated_at) VALUES (?, ?, ?, ?, ?)', [resource.path, resource.name, baseUrl, createdAt, createdAt]);
+    }
+    async getResource(key) {
+        const resource = this.resources.find(r => `${r.path}.${r.name}` === key);
+        if (resource) {
+            return resource;
+        }
+        // Split the key with format path.path.path.*.Name
+        const pathName = key.split('.');
+        const name = pathName.pop();
+        const path = pathName.join('.');
+        const result = await this.db.get('SELECT * FROM resources WHERE path = ? AND name = ?', [path, name]);
+        if (!result) {
+            return undefined;
+        }
+        const resourceFunctions = await this.db.all('SELECT * FROM resource_functions WHERE resource_id = ?', [result.id]);
+        return {
+            path: result.path,
+            name: result.name,
+            functions: await Promise.all(resourceFunctions.map(async (f) => ({
+                name: f.name,
+                returnType: f.return_type,
+                parameters: await this.getResourceParameters(f.id),
+                // The ExternalResourceInvoker will handle the execution of the function
+                exec: async () => {
+                    return void 0;
+                }
+            }))),
+            metadata: {
+                baseUrl: result.base_url,
+            }
+        };
+    }
+    async getExternalResources() {
+        const results = await this.db.get('SELECT * FROM resources');
+        if (!results) {
+            return [];
+        }
+        return Promise.all(results.map(async (r) => ({
+            path: r.path,
+            name: r.name,
+            functions: await Promise.all(r.resource_functions.map(async (f) => ({
+                name: f.name,
+                returnType: f.return_type,
+                parameters: await this.getResourceParameters(f.id),
+            }))),
+            metadata: {
+                baseUrl: r.base_url,
+            }
+        })));
+    }
+    async getResourceParameters(resourceFunctionId) {
+        return (await this.db.all('SELECT * FROM resource_function_parameters WHERE resource_function_id = ?', [resourceFunctionId])).map(p => ({
+            name: p.name,
+            type: p.parameter_type,
+        }));
+    }
+    async getAllResources() {
+        const externalResources = await this.getExternalResources();
+        let resources = [];
+        for (const resource of Object.values(this.resources)) {
+            resources.push({ ...resource, baseUrl: process.env.BASE_URL });
+        }
+        for (const resource of externalResources) {
+            resources.push({ ...resource, baseUrl: resource.metadata.baseUrl });
+        }
+        return resources;
+    }
+}

package/dist/routes.d.ts

@@ -0,0 +1,13 @@
+import type { FastifyPluginAsync } from 'fastify';
+import type { Service } from './service.js';
+interface RouteOptions {
+    service: Service;
+}
+/**
+ * Encapsulates the routes
+ * @param fastify Encapsulated Fastify Instance
+ * @param options plugin options, refer to https://fastify.dev/docs/latest/Reference/Plugins/#plugin-options
+ */
+declare const routes: FastifyPluginAsync<RouteOptions>;
+export default routes;
+//# sourceMappingURL=routes.d.ts.map

package/dist/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAI5C,UAAU,YAAY;IAClB,OAAO,EAAE,OAAO,CAAC;CACpB;AAED;;;;GAIG;AACH,QAAA,MAAM,MAAM,EAAE,kBAAkB,CAAC,YAAY,CA2D5C,CAAA;eAGc,MAAM"}

package/dist/routes.js

@@ -0,0 +1,57 @@
+import { interpretParsed, parseScript } from 'requestscript';
+/**
+ * Encapsulates the routes
+ * @param fastify Encapsulated Fastify Instance
+ * @param options plugin options, refer to https://fastify.dev/docs/latest/Reference/Plugins/#plugin-options
+ */
+const routes = async function (fastify, options) {
+    // Start Meta Routes
+    fastify.get('/', async (request, reply) => {
+        return { hello: 'world' };
+    });
+    fastify.get('/peers', async (request, reply) => {
+        const peers = await options.service.peerRepository.getPeerList();
+        return { peers };
+    });
+    /**
+     * Returns the list of resources that are available on the server.
+     * Does not return resources that are external to the server.
+     */
+    fastify.get('/resources', async (request, reply) => {
+        const resources = await options.service.resourceRepository.getAllResources();
+        return {
+            resources: resources.map((resource) => ({
+                path: resource.path,
+                name: resource.name,
+                functions: resource.functions.map((fn) => ({
+                    name: fn.name,
+                    returnType: fn.returnType,
+                    parameters: fn.parameters,
+                })),
+                baseUrl: resource.baseUrl,
+            })),
+        };
+    });
+    // End Meta Routes
+    // Start Run Routes
+    fastify.post('/run', async (request, reply) => {
+        const source = request.body;
+        try {
+            const script = parseScript(source);
+            if (script.declaration.kind !== 'request') {
+                return reply.status(400).send({ error: 'Invalid script' });
+            }
+            const result = await interpretParsed(script, {
+                resourceResolver: options.service.resourceResolver,
+                resourceInvoker: options.service.resourceInvoker
+            });
+            reply.status(200).send({ returnValue: result.returnValue ?? null });
+        }
+        catch (error) {
+            reply.status(500).send({ error: 'Internal server error' });
+        }
+    });
+    // End Run Routes
+};
+// ESM
+export default routes;

package/dist/server.d.ts

@@ -0,0 +1,13 @@
+import 'dotenv/config';
+import { FastifyInstance } from 'fastify';
+import { Resource } from 'requestscript';
+export interface StellariumNodeOptions {
+    port?: number;
+    startingPeer?: string;
+}
+export declare class StellariumNode {
+    private resources;
+    register(resource: Resource): Promise<void>;
+    start(fastify: FastifyInstance, options: StellariumNodeOptions): Promise<void>;
+}
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,CAAC;AACvB,OAAgB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAInD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAGzC,MAAM,WAAW,qBAAqB;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,qBAAa,cAAc;IACvB,OAAO,CAAC,SAAS,CAAkB;IAE7B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAEhD;IAEK,KAAK,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAyBnF;CACJ"}

package/dist/server.js

@@ -0,0 +1,32 @@
+import 'dotenv/config';
+import routes from './routes.js';
+import { createService } from './service.js';
+import { StartupService } from './startup.js';
+import { createTables } from './db/db.js';
+export class StellariumNode {
+    resources = [];
+    async register(resource) {
+        this.resources.push(resource);
+    }
+    async start(fastify, options) {
+        ;
+        const service = createService(this.resources);
+        await createTables();
+        fastify.register(routes, { prefix: '/v1', service });
+        // Run the server!
+        fastify.listen({ port: options.port ?? 3000 }, function (err, address) {
+            if (err) {
+                fastify.log.error(err);
+                process.exit(1);
+            }
+            if (options.startingPeer) {
+                const startupService = new StartupService(service, options.startingPeer);
+                Promise.resolve(startupService.loadFromPeer()).catch(err => {
+                    fastify.log.error(err);
+                    process.exit(1);
+                });
+            }
+            fastify.log.info(`server listening on ${address}`);
+        });
+    }
+}

package/dist/service.d.ts

@@ -0,0 +1,11 @@
+import { Resource, ResourceInvoker, ResourceResolver } from "requestscript";
+import { PeerRepository } from "./peer/repository.js";
+import { ResourceRepository } from "./resource/resource.js";
+export interface Service {
+    peerRepository: PeerRepository;
+    resourceRepository: ResourceRepository;
+    resourceResolver: ResourceResolver;
+    resourceInvoker: ResourceInvoker;
+}
+export declare function createService(resources: Resource[]): Service;
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAE5E,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,MAAM,WAAW,OAAO;IACpB,cAAc,EAAE,cAAc,CAAC;IAC/B,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,eAAe,EAAE,eAAe,CAAC;CACpC;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,QAAQ,EAAE,GAAG,OAAO,CAW5D"}

package/dist/service.js

@@ -0,0 +1,16 @@
+import db from "./db/db.js";
+import { PeerRepository } from "./peer/repository.js";
+import { CombinationResourceResolver } from "./resource/resolver.js";
+import { ResourceRepository } from "./resource/resource.js";
+import { CombinationResourceInvoker } from "./resource/invoker.js";
+export function createService(resources) {
+    const resourceRepository = new ResourceRepository(db, resources);
+    const resourceResolver = new CombinationResourceResolver(resourceRepository);
+    const resourceInvoker = new CombinationResourceInvoker();
+    return {
+        peerRepository: new PeerRepository(db),
+        resourceRepository,
+        resourceResolver,
+        resourceInvoker,
+    };
+}

package/dist/startup.d.ts

@@ -0,0 +1,10 @@
+import { Service } from "./service.js";
+export declare class StartupService {
+    private readonly service;
+    private readonly startingPeer;
+    constructor(service: Service, startingPeer: string);
+    loadFromPeer(): Promise<void>;
+    populatePeers(): Promise<void>;
+    populateResources(): Promise<void>;
+}
+//# sourceMappingURL=startup.d.ts.map

package/dist/startup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"startup.d.ts","sourceRoot":"","sources":["../src/startup.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAGvC,qBAAa,cAAc;IACX,OAAO,CAAC,QAAQ,CAAC,OAAO;IAAW,OAAO,CAAC,QAAQ,CAAC,YAAY;IAA5E,YAA6B,OAAO,EAAE,OAAO,EAAmB,YAAY,EAAE,MAAM,EAAI;IAGlF,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAGlC;IAEK,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAiBnC;IAEK,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CAYvC;CACJ"}

package/dist/startup.js

@@ -0,0 +1,41 @@
+export class StartupService {
+    service;
+    startingPeer;
+    constructor(service, startingPeer) {
+        this.service = service;
+        this.startingPeer = startingPeer;
+    }
+    // If the peer list is empty, populate it using the peer start parameter.
+    async loadFromPeer() {
+        await this.populatePeers();
+        await this.populateResources();
+    }
+    async populatePeers() {
+        const peerList = await this.service.peerRepository.getPeerList();
+        if (peerList.length > 0) {
+            return;
+        }
+        const response = await fetch(`${this.startingPeer}/v1/peers`);
+        const data = await response.json();
+        if (!data.peers) {
+            throw new Error('Invalid response from peer');
+        }
+        if (data.peers) {
+            for (const peer of data.peers) {
+                await this.service.peerRepository.create(peer);
+            }
+        }
+    }
+    async populateResources() {
+        const response = await fetch(`${this.startingPeer}/v1/resources`);
+        const data = await response.json();
+        if (!data.resources) {
+            throw new Error('Invalid response from peer');
+        }
+        if (data.resources) {
+            for (const resource of data.resources) {
+                await this.service.resourceRepository.create(resource, resource.baseUrl);
+            }
+        }
+    }
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "stellarium-ts",
+  "version": "0.1.0",
+  "description": "A Stellarium Node in TypeScript.",
+  "homepage": "https://github.com/qualletio/stellarium-ts#readme",
+  "bugs": {
+    "url": "https://github.com/qualletio/stellarium-ts/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/qualletio/stellarium-ts.git"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "decentralized",
+    "stellarium",
+    "requestscript"
+  ],
+  "author": "Christopher Poulsen <christopher.poulsen@quallet.io>",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "^26.6.4",
+    "typescript": "^7.0.2"
+  },
+  "dependencies": {
+    "dotenv": "^18.0.5",
+    "fastify": "^5.12.5",
+    "requestscript": "^1.0.5",
+    "sqlite": "^5.1.1",
+    "sqlite3": "^6.0.1"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "start": "node dist/server.js",
+    "dev": "node --watch src/server.ts",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
+}