@m1cro/server-sdk 0.1.0

package/dist/globals.d.ts

@@ -0,0 +1,13 @@
+import * as console from 'node:console';
+
+declare const logLevels: readonly ["trace", "debug", "info", "warn", "error", "none"];
+type LogLevel = (typeof logLevels)[number];
+
+declare global {
+    interface Console extends console.Console {
+        logLevel: LogLevel;
+    }
+    interface Request {
+        artifacts?: any;
+    }
+}

package/dist/globals.js

@@ -0,0 +1,2 @@
+//# sourceMappingURL=globals.js.map
+//# sourceMappingURL=globals.js.map

package/dist/globals.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"globals.js","sourcesContent":[]}

package/dist/index.d.ts

@@ -0,0 +1,273 @@
+import { JSONSchema4 } from 'json-schema';
+
+interface Crypto {
+    deriveKey(seed: string, length: number): Uint8Array;
+    aesGcmEncrypt<T>(data: T): Uint8Array;
+    aesGcmDecrypt<T>(data: Uint8Array): T;
+    argon2Hash(algorithm: Argon2Algorithm, password: string, options?: Argon2Options): string;
+    argon2Verify(algorithm: Argon2Algorithm, password: string, hash: string, options?: Argon2Options): boolean;
+}
+type Argon2Algorithm = 'argon2d' | 'argon2i' | 'argon2id';
+interface Argon2Options {
+    mCost?: number;
+    tCost?: number;
+    pCost?: number;
+    outputLen?: number;
+}
+
+type Record<K extends string | number | symbol = string, V = any> = {
+    [key in K]: V;
+};
+type Variant<K extends PropertyKey, T extends object> = {
+    [P in keyof T]: ({
+        [Q in K]: P;
+    } & T[P]) extends infer U ? {
+        [Q in keyof U]: U[Q];
+    } : never;
+}[keyof T];
+type EventHandler = <T>(this: App, event: string, data: T) => void | Promise<void>;
+type Visibility = 'private' | 'platform' | 'vendor' | 'public';
+interface Tenant {
+    id: string;
+    host: string;
+}
+interface AppId {
+    namespace: string;
+    app: string;
+}
+type AppRole = Variant<"type", AppRoleData>;
+type AppRoleData = {
+    provider: {
+        group: string;
+    };
+    test: void;
+};
+interface Auth {
+    subject: Subject;
+    permissions: Permissions;
+}
+interface Subject {
+    id: string;
+    email: string;
+    roles: string[];
+}
+interface Permissions {
+    [key: string]: string[];
+}
+interface HookEventMap {
+    "start": [];
+    "install": [];
+}
+
+interface FindQuery<T extends Record = Record> {
+    limit(limit: number): this;
+    offset(offset: number): this;
+    sort(sort: Sorting): this;
+    exec(): Promise<T[]>;
+}
+interface FindOneQuery<T extends Record = Record> {
+    offset(offset: number): this;
+    sort(sort: Sorting): this;
+    exec(): Promise<T | undefined>;
+}
+
+type InsertReturnMode = 'insertedIds' | 'documents';
+type InsertReturnType<T extends Record, R extends InsertReturnMode> = R extends 'insertedIds' ? string[] : R extends 'documents' ? T[] : never;
+interface InsertQuery<T extends Record = Record, R extends InsertReturnMode = 'insertedIds'> {
+    return(mode: 'insertedIds'): InsertQuery<T, 'insertedIds'>;
+    return(mode: 'documents'): InsertQuery<T, 'documents'>;
+    return(mode: InsertReturnMode): InsertQuery<T, typeof mode>;
+    exec(): Promise<InsertReturnType<T, R>>;
+}
+type InsertOneReturnMode = 'insertedId' | 'document';
+type InsertOneReturnType<T extends Record, R extends InsertOneReturnMode> = R extends 'insertedId' ? string : R extends 'document' ? T : never;
+interface InsertOneQuery<T extends Record = Record, R extends InsertOneReturnMode = 'insertedId'> {
+    return(mode: 'insertedId'): InsertOneQuery<T, 'insertedId'>;
+    return(mode: 'document'): InsertOneQuery<T, 'document'>;
+    return(mode: InsertOneReturnMode): InsertOneQuery<T, typeof mode>;
+    exec(): Promise<InsertOneReturnType<T, R>>;
+}
+
+type UpdateReturnMode = 'affectedRows' | 'oldDocuments' | 'newDocuments';
+type UpdateReturnType<T, R extends UpdateReturnMode> = R extends 'affectedRows' ? bigint : R extends 'oldDocuments' | 'newDocuments' ? T[] : never;
+interface UpdateQuery<T extends Record = Record, R extends UpdateReturnMode = 'affectedRows'> {
+    limit(limit: number): this;
+    offset(offset: number): this;
+    sort(sort: Sorting): this;
+    return(mode: 'affectedRows'): UpdateQuery<T, 'affectedRows'>;
+    return(mode: 'oldDocuments'): UpdateQuery<T, 'oldDocuments'>;
+    return(mode: 'newDocuments'): UpdateQuery<T, 'newDocuments'>;
+    return(mode: UpdateReturnMode): UpdateQuery<T, typeof mode>;
+    exec(): Promise<UpdateReturnType<T, R>>;
+}
+type UpdateOneReturnMode = 'success' | 'oldDocument' | 'newDocument';
+type UpdateOneReturnType<T, R extends UpdateOneReturnMode> = R extends 'success' ? boolean : R extends 'oldDocument' | 'newDocument' ? (T | undefined) : never;
+interface UpdateOneQuery<T extends Record = Record, R extends UpdateOneReturnMode = 'success'> {
+    offset(offset: number): this;
+    sort(sort: Sorting): this;
+    return(mode: 'success'): UpdateOneQuery<T, 'success'>;
+    return(mode: 'oldDocument'): UpdateOneQuery<T, 'oldDocument'>;
+    return(mode: 'newDocument'): UpdateOneQuery<T, 'newDocument'>;
+    return(mode: UpdateOneReturnMode): UpdateOneQuery<T, typeof mode>;
+    exec(): Promise<UpdateOneReturnType<T, R>>;
+}
+
+type RemoveReturnMode = 'affectedRows' | 'documents';
+type RemoveReturnType<T, R extends RemoveReturnMode> = R extends 'affectedRows' ? bigint : R extends 'documents' ? T[] : never;
+interface RemoveQuery<T extends Record = Record, R extends RemoveReturnMode = 'affectedRows'> {
+    limit(limit: number): this;
+    offset(offset: number): this;
+    sort(sort: Sorting): this;
+    return(mode: 'affectedRows'): RemoveQuery<T, 'affectedRows'>;
+    return(mode: 'documents'): RemoveQuery<T, 'documents'>;
+    return(mode: RemoveReturnMode): RemoveQuery<T, typeof mode>;
+    exec(): Promise<RemoveReturnType<T, R>>;
+}
+type RemoveOneReturnMode = 'success' | 'document';
+type RemoveOneReturnType<T, R extends RemoveOneReturnMode> = R extends 'success' ? boolean : R extends 'document' ? (T | undefined) : never;
+interface RemoveOneQuery<T extends Record = Record, R extends RemoveOneReturnMode = 'success'> {
+    offset(offset: number): this;
+    sort(sort: Sorting): this;
+    return(mode: 'success'): RemoveOneQuery<T, 'success'>;
+    return(mode: 'document'): RemoveOneQuery<T, 'document'>;
+    return(mode: RemoveOneReturnMode): RemoveOneQuery<T, typeof mode>;
+    exec(): Promise<RemoveOneReturnType<T, R>>;
+}
+
+interface Entity<T extends object = Record<string, unknown>> {
+    get name(): string;
+    find(query: Record): FindQuery<T>;
+    findOne(query: Record): FindOneQuery<T>;
+    insert(docs: T[]): InsertQuery<T>;
+    insertOne(doc: T): InsertOneQuery<T>;
+    update(query: Record, update: Record): UpdateQuery<T>;
+    updateOne(query: Record, update: Record): UpdateOneQuery<T>;
+    remove(query: Record): RemoveQuery<T>;
+    removeOne(query: Record): RemoveOneQuery<T>;
+}
+interface Sorting {
+    [field: string]: 'asc' | 'desc';
+}
+
+interface SetOptions {
+    ttl?: number;
+    existenceCheck?: "nx" | "xx";
+}
+interface KeyValueStore {
+    get<T>(key: string): Promise<T>;
+    getDel<T>(key: string): Promise<T>;
+    set<T>(key: string, value: T, options?: SetOptions): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+
+interface Providers {
+    list(group: string): Provider[];
+}
+interface Provider {
+    group: string;
+    app: AppId;
+}
+
+interface Artifacts {
+    get<T>(key: string): T | undefined;
+    set<T>(key: string, value: T): void;
+    delete(key: string): void;
+}
+
+interface Router {
+    scope(path: string): Router;
+    route(method: Method, path: string, handler: RequestHandler, options?: RouteOptions): Router;
+    get(path: string, handler: RequestHandler, options?: RouteOptions): Router;
+    post(path: string, handler: RequestHandler, options?: RouteOptions): Router;
+    put(path: string, handler: RequestHandler, options?: RouteOptions): Router;
+    patch(path: string, handler: RequestHandler, options?: RouteOptions): Router;
+    delete(path: string, handler: RequestHandler, options?: RouteOptions): Router;
+}
+interface RouteOptions {
+    timeoutMs?: number;
+    permissions?: string[];
+    authenticated?: boolean;
+    visibility?: Visibility;
+}
+type Method = 'get' | 'post' | 'put' | 'patch' | 'delete';
+type RequestHandler = (this: App, req: Request, res: Response) => void | Promise<void>;
+interface Request {
+    get artifacts(): Artifacts;
+    get method(): Method;
+    withMethod(method: Method): Request;
+    get url(): URL;
+    withUrl(url: string | URL): Request;
+    header(name: string): string | undefined;
+    withHeader(name: string, value: string): Request;
+    get headers(): Headers;
+    withHeaders(headers: HeadersInit): Request;
+    body(): Promise<Uint8Array>;
+    withBody(bytes: Uint8Array): Request;
+    text(): Promise<string>;
+    withText(text: string): Request;
+    json<T>(): Promise<T>;
+    withJson<T>(json: T): Request;
+}
+interface Response {
+    get status(): number;
+    withStatus(status: number): Response;
+    header(name: string): string | undefined;
+    withHeader(name: string, value: string): Response;
+    get headers(): Headers;
+    withHeaders(headers: HeadersInit): Response;
+    body(): Promise<Uint8Array>;
+    withBody(bytes: Uint8Array): Response;
+    text(): Promise<string>;
+    withText(text: string): Response;
+    json<T>(): Promise<T>;
+    withJson<T>(json: T): Response;
+}
+
+interface RPC {
+    call(url: string, method: Method): Call;
+    get(url: string): Call;
+    post(url: string): Call;
+    put(url: string): Call;
+    patch(url: string): Call;
+    delete(url: string): Call;
+}
+interface Call extends Request {
+    send(): Promise<Response>;
+}
+
+interface SSE {
+    push<T>(event: T, targets: string[]): Promise<void>;
+}
+
+interface App {
+    get tenant(): Tenant;
+    get providers(): Providers;
+    settings<T>(): T | undefined;
+    crd<T>(key: string): T | undefined;
+    get rpc(): RPC;
+    get kv(): KeyValueStore;
+    get sse(): SSE;
+    get crypto(): Crypto;
+    entity<T extends object>(name: string): Entity<T>;
+    publish<T extends object>(event: string, payload: T, visibility?: Visibility[]): void;
+}
+
+declare const _default: {
+    encode<T>(data: T): Uint8Array;
+    decode<T>(data: Uint8Array): T;
+};
+
+type EntryPoint = (builder: AppBuilder) => unknown;
+interface AppBuilder {
+    on<K extends keyof HookEventMap>(type: K, listener: (this: App, ...args: HookEventMap[K]) => unknown): AppBuilder;
+    role(role: AppRole): AppBuilder;
+    capability(app: string, permissions: string[]): AppBuilder;
+    capabilities(capabilities: {
+        [app: string]: string[];
+    }): AppBuilder;
+    routes(factory: (router: Router) => unknown): AppBuilder;
+    entity(name: string, schema: JSONSchema4): AppBuilder;
+    subscribe(pattern: string, handler: EventHandler): AppBuilder;
+}
+
+export { type App, type AppBuilder, type AppId, type AppRole, type Artifacts, type Auth, type Entity, type EntryPoint, type Providers, type Request, type RequestHandler, type Response, type RouteOptions, type Router, type Tenant, _default as cbor };

package/dist/index.js

@@ -0,0 +1,2 @@
+import*as e from'cbor2';var t={encode(p){return e.encode(p)},decode(p){return e.decode(p)}};export{t as cbor};//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cbor.ts"],"names":["cbor_default","data"],"mappings":"wBAEA,IAAOA,CAAAA,CAAQ,CACX,MAAA,CAAUC,CAAAA,CAAqB,CAC3B,OAAa,CAAA,CAAA,MAAA,CAAOA,CAAI,CAC5B,CAAA,CACA,OAAUA,CAAAA,CAAqB,CAC3B,OAAa,CAAA,CAAA,MAAA,CAAOA,CAAI,CAC5B,CACJ","file":"index.js","sourcesContent":["import * as cbor2 from \"cbor2\";\n\nexport default {\n    encode<T>(data: T): Uint8Array {\n        return cbor2.encode(data);\n    },\n    decode<T>(data: Uint8Array): T {\n        return cbor2.decode(data);\n    },\n};\n"]}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@m1cro/server-sdk",
+  "version": "0.1.0",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./globals": {
+      "types": "./dist/globals.d.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "yarn run typecheck && yarn run bundle",
+    "typecheck": "tsc --noEmit",
+    "bundle": "tsup --minify --treeshake smallest",
+    "versioning": "yarn version --new-version",
+    "deploy": "yarn publish --non-interactive"
+  },
+  "dependencies": {
+    "@types/json-schema": "^7.0.15",
+    "cbor2": "^2.2.1",
+    "json-schema": "^0.4.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1"
+  }
+}