rlz-engine 1.0.33 → 1.0.35

package/dist/back/auth/controllers.d.ts

@@ -1,5 +1,5 @@
 import { FastifyInstance, RawServerBase } from 'fastify';
-import { AuthStorage } from './storage';
+import { AuthStorage } from './storage.js';
 interface AuthEndpointsOpts {
     storage: AuthStorage;
 }

package/dist/back/auth/controllers.js

@@ -1,8 +1,8 @@
 import { httpErrors } from '@fastify/sensible';
 import fastifyPlugin from 'fastify-plugin';
-import zodToJsonSchema from 'zod-to-json-schema';
-import { API_AUTH_RESPONSE_SCHEMA_V0, API_SIGNIN_REQUEST_SCHEMA_V0, API_SIGNUP_REQUEST_SCHEMA_V0 } from '../../shared/api/auth';
-import { logout, signin, signup } from './utils';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { API_AUTH_RESPONSE_SCHEMA_V0, API_SIGNIN_REQUEST_SCHEMA_V0, API_SIGNUP_REQUEST_SCHEMA_V0 } from '../../shared/api/auth.js';
+import { logout, signin, signup } from './utils.js';
 export const AUTH_API = fastifyPlugin(async function authApi(app, { storage }) {
     app.post('/api/v0/signup', {
         schema: {

package/dist/back/auth/storage.d.ts

@@ -1,7 +1,7 @@
 import { FastifyRequest } from 'fastify';
 import { Binary, Collection } from 'mongodb';
-import { MongoStorage } from '../storage/db';
-import { StorageTempPassword, StorageUser } from './model';
+import { MongoStorage } from '../storage/db.js';
+import { StorageTempPassword, StorageUser } from './model.js';
 export declare class AuthStorage {
     private readonly logger;
     private readonly mongo;

package/dist/back/auth/storage.js

@@ -1,6 +1,6 @@
 import { DateTime } from 'luxon';
-import { logger } from '../logger';
-import { auth } from './utils';
+import { logger } from '../logger.js';
+import { auth } from './utils.js';
 export class AuthStorage {
     logger = logger('AuthStorage');
     mongo;

package/dist/back/auth/utils.d.ts

@@ -1,6 +1,6 @@
 import { FastifyRequest } from 'fastify';
-import { ApiAuthResponseV0 } from '../../shared/api/auth';
-import { AuthStorage } from './storage';
+import { ApiAuthResponseV0 } from '../../shared/api/auth.js';
+import { AuthStorage } from './storage.js';
 export declare function signup(storage: AuthStorage, name: string, email: string, password: string): Promise<ApiAuthResponseV0>;
 export declare function signin(storage: AuthStorage, name: string, password: string): Promise<ApiAuthResponseV0 | null>;
 export declare function logout(storage: AuthStorage, userId: string, tempPassword: string): Promise<void>;

package/dist/back/logger.js

@@ -1,6 +1,6 @@
 import { produce } from 'immer';
 import { pino } from 'pino';
-import { PRODUCTION } from './config';
+import { PRODUCTION } from './config.js';
 export function logger(name, optionsRecipe) {
     const options = optionsRecipe === undefined
         ? loggerOptions(name)

package/dist/back/rpc/gen.d.ts

@@ -0,0 +1,2 @@
+import { RpcPluginBuilder } from './rpc.js';
+export declare function generateClient(fileName: string, ...rpcBuilders: readonly RpcPluginBuilder[]): string;

package/dist/back/rpc/gen.js

@@ -0,0 +1,63 @@
+import ts, { NewLineKind, ScriptKind, ScriptTarget } from 'typescript';
+import { createTypeAlias, zodToTs } from 'zod-to-ts';
+const F = ts.factory;
+export function generateClient(fileName, ...rpcBuilders) {
+    const sourceFile = ts.createSourceFile(fileName, '', ScriptTarget.Latest, false, ScriptKind.TS);
+    const printer = ts.createPrinter({ newLine: NewLineKind.CarriageReturnLineFeed });
+    const p = (node) => {
+        return printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
+    };
+    const fileContent = [];
+    fileContent.push(p(F.createImportDeclaration(undefined, F.createImportClause(false, undefined, F.createNamedImports([
+        F.createImportSpecifier(false, undefined, F.createIdentifier('AuthParam')),
+        F.createImportSpecifier(false, undefined, F.createIdentifier('rpcCall'))
+    ])), F.createStringLiteral('rlz-engine/client/rpc.js'), undefined)));
+    for (const b of rpcBuilders) {
+        for (const e of b.endpoints) {
+            fileContent.push(...generateTypes(b.name, e, p));
+        }
+    }
+    const props = rpcBuilders.map((b) => {
+        const calls = b.endpoints.map((e) => {
+            return F.createPropertyAssignment(F.createIdentifier(e.name), F.createArrowFunction([F.createToken(ts.SyntaxKind.AsyncKeyword)], undefined, e.anonimous
+                ? [
+                    F.createParameterDeclaration(undefined, undefined, F.createIdentifier('body'), undefined, F.createTypeReferenceNode(F.createIdentifier(createBodyTypeName(b.name, e)), undefined), undefined)
+                ]
+                : [
+                    F.createParameterDeclaration(undefined, undefined, F.createIdentifier('auth'), undefined, F.createTypeReferenceNode(F.createIdentifier('AuthParam'), undefined), undefined),
+                    F.createParameterDeclaration(undefined, undefined, F.createIdentifier('body'), undefined, F.createTypeReferenceNode(F.createIdentifier(createBodyTypeName(b.name, e)), undefined), undefined)
+                ], F.createTypeReferenceNode(F.createIdentifier('Promise'), [F.createTypeReferenceNode(F.createIdentifier(createRespTypeName(b.name, e)), undefined)]), F.createToken(ts.SyntaxKind.EqualsGreaterThanToken), F.createBlock([F.createReturnStatement(F.createAwaitExpression(F.createCallExpression(F.createIdentifier('rpcCall'), undefined, [
+                    e.anonimous ? F.createNull() : F.createIdentifier('auth'),
+                    F.createStringLiteral(b.name),
+                    F.createStringLiteral(e.name),
+                    F.createNumericLiteral(e.v),
+                    F.createIdentifier('body')
+                ])))], true)));
+        });
+        return F.createPropertyAssignment(F.createIdentifier(b.name), F.createObjectLiteralExpression(calls, false));
+    });
+    const rpcClientNode = F.createVariableStatement([F.createToken(ts.SyntaxKind.ExportKeyword)], F.createVariableDeclarationList([F.createVariableDeclaration(F.createIdentifier('RPC_CLIENT'), undefined, undefined, F.createObjectLiteralExpression(props, false))], ts.NodeFlags.Const));
+    fileContent.push(p(rpcClientNode));
+    return fileContent.join('\n');
+}
+function generateTypes(rpcName, e, p) {
+    const resp = [];
+    const bodyTypeName = createBodyTypeName(rpcName, e);
+    const bodyType = zodToTs(e.bodySchema, bodyTypeName);
+    const bodyTypeAlias = createTypeAlias(bodyType.node, bodyTypeName);
+    resp.push(p(bodyTypeAlias));
+    const respTypeName = createRespTypeName(rpcName, e);
+    const respType = zodToTs(e.respSchema, respTypeName);
+    const respTypeAlias = createTypeAlias(respType.node, respTypeName);
+    resp.push(p(respTypeAlias));
+    return resp;
+}
+function firstLetterUp(text) {
+    return `${text[0].toUpperCase()}${text.substring(1)}`;
+}
+function createBodyTypeName(rpcName, e) {
+    return `RpcBody${firstLetterUp(rpcName)}${firstLetterUp(e.name)}V${e.v}`;
+}
+function createRespTypeName(rpcName, e) {
+    return `RpcResp${firstLetterUp(rpcName)}${firstLetterUp(e.name)}V${e.v}`;
+}

package/dist/back/rpc/rpc.d.ts

@@ -0,0 +1,49 @@
+import { FastifyInstance, FastifyPluginOptions, RawServerBase } from 'fastify';
+import z from 'zod';
+interface RpcEndpointCommon<BodyT extends object, RespT extends object> {
+    readonly v: number;
+    readonly name: string;
+    readonly bodySchema: z.Schema<BodyT>;
+    readonly respSchema: z.Schema<RespT>;
+}
+interface RpcEndpointAnon<BodyT extends object = object, RespT extends object = object, OptsT = never> extends RpcEndpointCommon<BodyT, RespT> {
+    readonly anonimous: true;
+    readonly action: (body: {
+        [k in keyof BodyT]: BodyT[k];
+    }, opts: OptsT) => {
+        [k in keyof RespT]: RespT[k];
+    } | Promise<{
+        [k in keyof RespT]: RespT[k];
+    }>;
+}
+interface RpcEndpointAuth<BodyT extends object = object, RespT extends object = object, OptsT = never, UserT = never> extends RpcEndpointCommon<BodyT, RespT> {
+    readonly anonimous?: false;
+    readonly auth: (userId: string, password: string) => UserT | Promise<UserT>;
+    readonly action: (user: UserT, body: {
+        [k in keyof BodyT]: BodyT[k];
+    }, opts: OptsT) => {
+        [k in keyof RespT]: RespT[k];
+    } | Promise<{
+        [k in keyof RespT]: RespT[k];
+    }>;
+}
+export type RpcEndpoint<BodyT extends object = object, RespT extends object = object, OptsT = never, UserT = never> = RpcEndpointAnon<BodyT, RespT, OptsT> | RpcEndpointAuth<BodyT, RespT, OptsT, UserT>;
+export interface RpcEndpointInfo {
+    v: number;
+    name: string;
+    anonimous: boolean;
+    bodySchema: z.Schema;
+    respSchema: z.Schema;
+}
+interface InnerRpcEndpoint<OptsT> extends RpcEndpointInfo {
+    reg: <T extends RawServerBase>(app: FastifyInstance<T>, opts: OptsT) => void;
+}
+export declare class RpcPluginBuilder<OptsT extends FastifyPluginOptions = never> {
+    readonly name: string;
+    readonly endpoints: InnerRpcEndpoint<OptsT>[];
+    constructor(name: string);
+    add<BodyT extends object, RespT extends object, UserT>(endpoint: RpcEndpoint<BodyT, RespT, OptsT, UserT>): this;
+    makeFastifyPlugin(): <T extends RawServerBase>(app: FastifyInstance<T>, opts: OptsT) => void;
+}
+export declare function rpc<OptsT extends FastifyPluginOptions>(name: string): RpcPluginBuilder<OptsT>;
+export {};

package/dist/back/rpc/rpc.js

@@ -0,0 +1,60 @@
+import { httpErrors } from '@fastify/sensible';
+import fastifyPlugin from 'fastify-plugin';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+function makeReg(pluginName, endpoint) {
+    return {
+        v: endpoint.v,
+        name: endpoint.name,
+        anonimous: endpoint.anonimous ?? false,
+        bodySchema: endpoint.bodySchema,
+        respSchema: endpoint.respSchema,
+        reg(app, opts) {
+            app.post(`/rpc/${pluginName}/${this.name}/v${this.v}`, {
+                schema: {
+                    body: zodToJsonSchema(this.bodySchema),
+                    response: {
+                        200: zodToJsonSchema(this.respSchema)
+                    }
+                }
+            }, endpoint.anonimous === true
+                ? async (req, resp) => {
+                    const body = req.body;
+                    const respBody = await endpoint.action(body, opts);
+                    resp.send(respBody);
+                }
+                : async (req, resp) => {
+                    const authHeader = req.headers.authorization;
+                    if (authHeader === undefined) {
+                        throw httpErrors.forbidden();
+                    }
+                    const [userId, password] = authHeader.split(':');
+                    const user = await endpoint.auth(userId, password);
+                    const body = req.body;
+                    const respBody = await endpoint.action(user, body, opts);
+                    resp.send(respBody);
+                });
+        }
+    };
+}
+export class RpcPluginBuilder {
+    name;
+    endpoints = [];
+    constructor(name) {
+        this.name = name;
+    }
+    add(endpoint) {
+        this.endpoints.push(makeReg(this.name, endpoint));
+        return this;
+    }
+    makeFastifyPlugin() {
+        const endpoints = this.endpoints;
+        return fastifyPlugin(function makeRpcPlugin(app, opts) {
+            for (const e of endpoints) {
+                e.reg(app, opts);
+            }
+        });
+    }
+}
+export function rpc(name) {
+    return new RpcPluginBuilder(name);
+}

package/dist/back/server.js

@@ -1,6 +1,6 @@
 import fastifyCompress from '@fastify/compress';
 import fastifyCors from '@fastify/cors';
-import fastifyResponseValidation from '@fastify/response-validation';
+import { fastifyResponseValidation } from '@fastify/response-validation';
 import fastifySensible, { httpErrors } from '@fastify/sensible';
 import fastifyStatic from '@fastify/static';
 import formatsPlugin from 'ajv-formats';
@@ -9,14 +9,14 @@ import { fastifyAcmeSecurePlugin, fastifyAcmeUnsecurePlugin, getCertAndKey } fro
 import { createReadStream } from 'fs';
 import { installIntoGlobal } from 'iterator-helpers-polyfill';
 import path from 'path';
-import { logger } from './logger';
+import { logger } from './logger.js';
 installIntoGlobal();
 const L = logger('init');
 export async function runServer({ production, domain, certDir, staticDir, init }) {
     L.info({ production }, 'runServer');
     const httpServer = fastify({
         loggerInstance: logger('http'),
-        ajv: { plugins: [formatsPlugin], customOptions: { useDefaults: false } }
+        ajv: { plugins: [formatsPlugin.default], customOptions: { useDefaults: false, coerceTypes: false, allErrors: true } }
     });
     if (!production) {
         await httpServer.register(fastifyCors, {
@@ -25,7 +25,7 @@ export async function runServer({ production, domain, certDir, staticDir, init }
         await httpServer.register(fastifyCompress);
         await httpServer.register(fastifySensible);
         await httpServer.register(fastifyResponseValidation, {
-            ajv: { plugins: [formatsPlugin], useDefaults: false }
+            ajv: { plugins: [formatsPlugin.default], useDefaults: false, coerceTypes: false, allErrors: true }
         });
         await init(httpServer);
         httpServer.all('/api/*', async () => {
@@ -48,7 +48,7 @@ export async function runServer({ production, domain, certDir, staticDir, init }
             key: certAndKey.pkey
         },
         loggerInstance: logger('https'),
-        ajv: { plugins: [formatsPlugin], customOptions: { useDefaults: false } }
+        ajv: { plugins: [formatsPlugin.default], customOptions: { useDefaults: false, coerceTypes: false, allErrors: true } }
     });
     await httpsServer.register(fastifyAcmeSecurePlugin, {
         certDir,
@@ -59,7 +59,7 @@ export async function runServer({ production, domain, certDir, staticDir, init }
     });
     await httpsServer.register(fastifyCompress);
     await httpsServer.register(fastifySensible);
-    await httpsServer.register(fastifyResponseValidation, { ajv: { plugins: [formatsPlugin], useDefaults: false } });
+    await httpsServer.register(fastifyResponseValidation, { ajv: { plugins: [formatsPlugin.default], useDefaults: false, coerceTypes: false, allErrors: true } });
     await init(httpsServer);
     httpsServer.all('/api/*', async () => {
         return httpErrors.notFound();

package/dist/back/storage/db.js

@@ -1,5 +1,5 @@
 import { MongoClient } from 'mongodb';
-import { logger } from '../logger';
+import { logger } from '../logger.js';
 export class MongoStorage {
     logger;
     client;

package/dist/back/storage/sync.d.ts

@@ -1,5 +1,5 @@
 import { DateTime } from 'luxon';
 import { Collection } from 'mongodb';
-import { ApiComparisonObjectV0 } from '../../shared/api/sync';
-import { SyncObject } from './model';
+import { ApiComparisonObjectV0 } from '../../shared/api/sync.js';
+import { SyncObject } from './model.js';
 export declare function getAll<T>(c: Collection<SyncObject<T>>, ownerId: string, syncAfter?: DateTime<true>): Promise<ApiComparisonObjectV0[]>;

package/dist/back/storage/sync.js

@@ -1,4 +1,4 @@
-import { SYNC_OBJECT_SCHEMA } from './model';
+import { SYNC_OBJECT_SCHEMA } from './model.js';
 export async function getAll(c, ownerId, syncAfter) {
     const items = [];
     const query = syncAfter === undefined

package/dist/client/api/api.js

@@ -1,4 +1,4 @@
-import { getFrontConfig } from '../config';
+import { getFrontConfig } from '../config.js';
 export class HttpError extends Error {
     method;
     url;

package/dist/client/api/auth.d.ts

@@ -1,5 +1,5 @@
-import { ApiAuthResponseV0 } from '../../shared/api/auth';
-import { AuthParam } from './api';
+import { ApiAuthResponseV0 } from '../../shared/api/auth.js';
+import { AuthParam } from './api.js';
 export declare function apiSignup(name: string, email: string, password: string): Promise<ApiAuthResponseV0>;
 export declare function apiSignin(name: string, password: string): Promise<ApiAuthResponseV0>;
 export declare function apiLogout(auth: AuthParam): Promise<void>;

package/dist/client/api/auth.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { API_AUTH_RESPONSE_SCHEMA_V0 } from '../../shared/api/auth';
-import { apiCall } from './api';
+import { API_AUTH_RESPONSE_SCHEMA_V0 } from '../../shared/api/auth.js';
+import { apiCall } from './api.js';
 export async function apiSignup(name, email, password) {
     const req = {
         name,

package/dist/client/rpc.d.ts

@@ -0,0 +1,21 @@
+export declare class HttpError extends Error {
+    readonly method: string;
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    constructor(method: string, url: string, status: number, statusText: string);
+}
+export declare class Unauthorized extends HttpError {
+    constructor(url: string, statusText: string);
+}
+export declare class Forbidden extends HttpError {
+    constructor(url: string, statusText: string);
+}
+export declare class NotFound extends HttpError {
+    constructor(url: string, statusText: string);
+}
+export interface AuthParam {
+    userId: string;
+    tempPassword: string;
+}
+export declare function rpcCall<BodyT extends object, RespT extends object>(auth: AuthParam | null, rpcName: string, callName: string, version: number, bodyObject: BodyT): Promise<RespT>;

package/dist/client/rpc.js

@@ -0,0 +1,75 @@
+import { getFrontConfig } from './config.js';
+export class HttpError extends Error {
+    method;
+    url;
+    status;
+    statusText;
+    constructor(method, url, status, statusText) {
+        super(`Not ok resp (${status} ${statusText}): ${method} ${url}`);
+        this.method = method;
+        this.url = url;
+        this.status = status;
+        this.statusText = statusText;
+    }
+}
+export class Unauthorized extends HttpError {
+    constructor(url, statusText) {
+        super('post', url, 401, statusText);
+    }
+}
+export class Forbidden extends HttpError {
+    constructor(url, statusText) {
+        super('post', url, 403, statusText);
+    }
+}
+export class NotFound extends HttpError {
+    constructor(url, statusText) {
+        super('post', url, 404, statusText);
+    }
+}
+function url(rpcName, callName, version) {
+    const domain = getFrontConfig().apiDomain;
+    return `${domain}rpc/${rpcName}/${callName}/v${version}`;
+}
+const GZIP_THRESHOLD = 16 * 1024;
+async function prepareBody(request) {
+    const textBody = JSON.stringify(request);
+    if (textBody.length <= GZIP_THRESHOLD) {
+        return textBody;
+    }
+    const bodyStream = new Blob([textBody]).stream();
+    const bodyStreamCompressed = bodyStream.pipeThrough(new CompressionStream('gzip'));
+    return new Response(bodyStreamCompressed).blob();
+}
+export async function rpcCall(auth, rpcName, callName, version, bodyObject) {
+    const headers = {};
+    const body = await prepareBody(bodyObject);
+    if (body !== undefined) {
+        headers['content-type'] = 'application/json';
+        if (typeof body !== 'string') {
+            headers['content-encoding'] = 'gzip';
+        }
+    }
+    if (auth !== null) {
+        headers['authorization'] = `${auth.userId}:${auth.tempPassword}`;
+    }
+    const u = url(rpcName, callName, version);
+    const resp = await fetch(u, {
+        method: 'post',
+        headers,
+        body
+    });
+    if (!resp.ok) {
+        if (resp.status === 401) {
+            throw new Unauthorized(u, resp.statusText);
+        }
+        if (resp.status === 403) {
+            throw new Forbidden(u, resp.statusText);
+        }
+        if (resp.status === 404) {
+            throw new NotFound(u, resp.statusText);
+        }
+        throw new HttpError('post', u, resp.status, resp.statusText);
+    }
+    return await resp.json();
+}

package/dist/client/screens/SignupSigninScreen.js

@@ -3,8 +3,8 @@ import React from 'react';
 import { useCallback, useState } from 'react';
 import { useLocation, useNavigate } from 'react-router-dom';
 import { z } from 'zod';
-import { apiSignin, apiSignup } from '../api/auth';
-import { useAuthState } from '../state/auth';
+import { apiSignin, apiSignup } from '../api/auth.js';
+import { useAuthState } from '../state/auth.js';
 export function SignupSigninScreen({ appName }) {
     const location = useLocation();
     const navigate = useNavigate();

package/dist/client/state/auth.d.ts

@@ -1,4 +1,4 @@
-import { AuthParam } from '../api/api';
+import { AuthParam } from '../api/api.js';
 export interface AuthState {
     id: string | null;
     name: string | null;

package/dist/client/state/auth.js

@@ -1,6 +1,6 @@
 import { create } from 'zustand';
 import { persist } from 'zustand/middleware';
-import { cacheLastResult } from './cached';
+import { cacheLastResult } from './cached.js';
 const AUTH_ID_KEY = 'AUTH_ID';
 const AUTH_NAME_KEY = 'AUTH_NAME';
 const AUTH_EMAIL_KEY = 'AUTH_EMAIL';

package/dist/client/sync.d.ts

@@ -1,5 +1,5 @@
 import { DateTime } from 'luxon';
-import { API_COMPARISON_OBJECT_SCHEMA_V0, ApiItemsResponseV0 } from '../shared/api/sync';
+import { API_COMPARISON_OBJECT_SCHEMA_V0, ApiItemsResponseV0 } from '../shared/api/sync.js';
 export declare function syncItems<T extends {
     id: string;
     lastModified: DateTime<true>;

package/dist/client/sync.js

@@ -1,5 +1,5 @@
 import { DateTime } from 'luxon';
-import { toValid } from '../shared/utils/datetime';
+import { toValid } from '../shared/utils/datetime.js';
 export async function syncItems({ getRemoteLastModified, localItems, pushRemote, getRemote, pushLocal, lastSyncDate }) {
     const remoteItems = (await getRemoteLastModified()).items;
     const remoteItemsMap = Object.fromEntries(remoteItems.map(i => [i.id, toValid(DateTime.fromISO(i.lastModified, { zone: 'utc' }))]));

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rlz-engine",
-    "version": "1.0.33",
+    "version": "1.0.35",
     "description": "Deps and tools for my style of development",
     "scripts": {
         "build": "tsc",
@@ -17,13 +17,18 @@
         "url": "git+https://github.com/rlz/rlz-engine.git"
     },
     "type": "module",
+    "exports": {
+        "./back/*": "./dist/back/*",
+        "./client/*": "./dist/client/*",
+        "./shared/*": "./dist/shared/*"
+    },
     "files": [
         "dist"
     ],
     "devDependencies": {
-        "@stylistic/eslint-plugin": "^4.2.0",
+        "@stylistic/eslint-plugin": "^5.0.0",
         "@types/luxon": "^3.4.2",
-        "@types/node": "^22.10.1",
+        "@types/node": "^24.0.5",
         "@typescript-eslint/parser": "^8.16.0",
         "eslint": "^9.16.0",
         "eslint-plugin-simple-import-sort": "^12.1.1",
@@ -66,6 +71,7 @@
         "uuidv7": "^1.0.2",
         "zod": "^3.23.8",
         "zod-to-json-schema": "^3.23.5",
+        "zod-to-ts": "^1.2.0",
         "zustand": "^5.0.3"
     }
 }