@livon/client 0.27.0-rc.1

package/dist/client.js

@@ -0,0 +1,314 @@
+const DEFAULT_REQUEST_KEY = 'livon.client.request';
+const setClientRequest = ({ client, registry, requestKey })=>{
+    if ('object' != typeof client || null === client || !('setRequest' in client)) return;
+    const candidate = client;
+    if ('function' != typeof candidate.setRequest) return;
+    candidate.setRequest((event, payload)=>{
+        const request = registry.state.get(requestKey);
+        if (!request) throw new Error('Client request handler is not available.');
+        return request(event, payload);
+    });
+};
+const buildClientEventEnvelope = (envelope)=>{
+    if ('payload' in envelope) return {
+        ...envelope,
+        payload: envelope.payload
+    };
+    return {
+        ...envelope,
+        error: envelope.error
+    };
+};
+const clientModule = (client, options = {})=>{
+    const register = (registry)=>{
+        const requestKey = options.requestKey ?? DEFAULT_REQUEST_KEY;
+        setClientRequest({
+            client,
+            registry,
+            requestKey
+        });
+        registry.onReceive((envelope, _ctx, next)=>{
+            client.emitEvent(buildClientEventEnvelope(envelope));
+            return next();
+        });
+    };
+    return {
+        name: options.name ?? 'client-module',
+        register
+    };
+};
+const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const isArray = (value)=>Array.isArray(value);
+const capitalize = (value)=>0 === value.length ? value : value.slice(0, 1).toUpperCase() + value.slice(1);
+const camelCaseName = (value)=>{
+    if (!value) return value;
+    return value.replace(/[^a-zA-Z0-9]+(.)/g, (_, group)=>String(group).toUpperCase()).replace(/^./, (char)=>char.toLowerCase());
+};
+const fieldMethodName = (owner, field)=>`$${camelCaseName(owner)}${capitalize(field)}`;
+const fieldEventName = (owner, field)=>`$${owner}.${field}`;
+const walkAst = (node, visit)=>{
+    visit(node);
+    node.children?.forEach((child)=>walkAst(child, visit));
+};
+const collectOperations = (root)=>{
+    const operations = [];
+    walkAst(root, (node)=>{
+        if ('operation' !== node.type || !node.name) return;
+        const input = node.children?.[0];
+        const output = node.children?.[1];
+        operations.push({
+            name: node.name,
+            input,
+            output,
+            event: node.name
+        });
+    });
+    return operations;
+};
+const collectFieldOperations = (root)=>{
+    const registry = new Map();
+    walkAst(root, (node)=>{
+        if ('field' !== node.type) return;
+        const constraints = node.constraints;
+        const owner = 'string' == typeof constraints?.owner ? constraints.owner : void 0;
+        const field = 'string' == typeof constraints?.field ? constraints.field : void 0;
+        if (!owner || !field) return;
+        const children = node.children ?? [];
+        const dependsOn = children[0];
+        const input = 3 === children.length ? children[1] : void 0;
+        const output = 3 === children.length ? children[2] : children[1];
+        if (!dependsOn) return;
+        const spec = {
+            owner,
+            field,
+            input,
+            output,
+            event: fieldEventName(owner, field)
+        };
+        if (!registry.has(owner)) registry.set(owner, new Map());
+        registry.get(owner).set(field, spec);
+    });
+    return registry;
+};
+const hydrateByNode = ({ value, node, registry, request })=>{
+    if (!node) return value;
+    if ('array' === node.type && isArray(value)) {
+        const child = node.children?.[0];
+        value.forEach((item, index)=>{
+            value[index] = hydrateByNode({
+                value: item,
+                node: child,
+                registry,
+                request
+            });
+        });
+        return value;
+    }
+    if ('tuple' === node.type && isArray(value)) {
+        const children = node.children ?? [];
+        value.forEach((item, index)=>{
+            value[index] = hydrateByNode({
+                value: item,
+                node: children[index],
+                registry,
+                request
+            });
+        });
+        return value;
+    }
+    if ('object' === node.type && isRecord(value)) {
+        const typeName = node.name;
+        if (typeName && registry.has(typeName)) attachFieldOperations({
+            target: value,
+            typeName,
+            registry,
+            request
+        });
+        const fields = node.children ?? [];
+        fields.forEach((fieldNode)=>{
+            if ('field' !== fieldNode.type || !fieldNode.name) return;
+            const child = fieldNode.children?.[0];
+            if (!child) return;
+            value[fieldNode.name] = hydrateByNode({
+                value: value[fieldNode.name],
+                node: child,
+                registry,
+                request
+            });
+        });
+        return value;
+    }
+    if ('field' === node.type) {
+        const child = node.children?.[0];
+        return hydrateByNode({
+            value,
+            node: child,
+            registry,
+            request
+        });
+    }
+    return value;
+};
+const attachFieldOperations = ({ target, typeName, registry, request })=>{
+    const operations = registry.get(typeName);
+    if (!operations) return;
+    if (!Object.isExtensible(target)) return;
+    operations.forEach((spec, fieldName)=>{
+        if (fieldName in target) return;
+        Object.defineProperty(target, fieldName, {
+            enumerable: false,
+            configurable: true,
+            value: async (input)=>{
+                const payload = {
+                    dependsOn: target,
+                    input
+                };
+                const result = await request(spec.event, payload);
+                return hydrateByNode({
+                    value: result,
+                    node: spec.output,
+                    registry,
+                    request
+                });
+            }
+        });
+    });
+};
+const normalizeFieldPayload = (payload)=>{
+    if (isRecord(payload) && 'dependsOn' in payload) {
+        const dependsOn = payload.dependsOn;
+        const input = 'input' in payload ? payload.input : void 0;
+        if (void 0 === input) return {
+            dependsOn
+        };
+        return {
+            dependsOn,
+            input
+        };
+    }
+    return {
+        dependsOn: payload
+    };
+};
+const createClientCore = ({ ast })=>{
+    const operations = collectOperations(ast);
+    const fieldRegistry = collectFieldOperations(ast);
+    let request;
+    const client = {};
+    client.setRequest = (next)=>{
+        request = next;
+    };
+    const globalHandlers = new Map();
+    const globalEnabled = new Map();
+    const roomHandlers = new Map();
+    const roomEnabled = new Map();
+    const registerHandlers = (handlers, roomId)=>{
+        const entries = Object.entries(handlers).filter(([, handler])=>'function' == typeof handler);
+        if (0 === entries.length) return;
+        if (!roomId) return void entries.forEach(([event, handler])=>{
+            globalHandlers.set(event, handler);
+            globalEnabled.set(event, true);
+        });
+        const roomMap = roomHandlers.get(roomId) ?? new Map();
+        const enabledMap = roomEnabled.get(roomId) ?? new Map();
+        entries.forEach(([event, handler])=>{
+            roomMap.set(event, handler);
+            enabledMap.set(event, true);
+        });
+        roomHandlers.set(roomId, roomMap);
+        roomEnabled.set(roomId, enabledMap);
+    };
+    const toggleHandler = ({ enabled, event, roomId })=>{
+        if (!roomId) return void globalEnabled.set(event, enabled);
+        const enabledMap = roomEnabled.get(roomId) ?? new Map();
+        enabledMap.set(event, enabled);
+        roomEnabled.set(roomId, enabledMap);
+    };
+    const dispatch = (envelope)=>{
+        const ctx = {
+            eventId: envelope.id,
+            event: envelope.event,
+            status: envelope.status,
+            metadata: envelope.metadata,
+            context: envelope.context,
+            room: 'string' == typeof envelope.metadata?.room ? String(envelope.metadata.room) : void 0
+        };
+        const roomId = ctx.room;
+        if (roomId) {
+            const enabledMap = roomEnabled.get(roomId);
+            const roomMap = roomHandlers.get(roomId);
+            const handler = roomMap?.get(envelope.event);
+            const isEnabled = enabledMap?.get(envelope.event) ?? true;
+            if (handler && isEnabled) handler(envelope.payload, ctx);
+        }
+        const handler = globalHandlers.get(envelope.event);
+        const isEnabled = globalEnabled.get(envelope.event) ?? true;
+        if (handler && isEnabled) handler(envelope.payload, ctx);
+    };
+    operations.forEach((op)=>{
+        client[op.name] = async (input)=>{
+            if (!request) throw new Error('Client request handler is not available.');
+            const result = await request(op.event, input);
+            return hydrateByNode({
+                value: result,
+                node: op.output,
+                registry: fieldRegistry,
+                request
+            });
+        };
+    });
+    fieldRegistry.forEach((fields, owner)=>{
+        fields.forEach((spec, field)=>{
+            const method = fieldMethodName(owner, field);
+            if (method in client) return;
+            client[method] = async (payload, input)=>{
+                const normalized = normalizeFieldPayload(payload);
+                if (!request) throw new Error('Client request handler is not available.');
+                const result = await request(spec.event, {
+                    dependsOn: normalized.dependsOn,
+                    input: input ?? normalized.input
+                });
+                return hydrateByNode({
+                    value: result,
+                    node: spec.output,
+                    registry: fieldRegistry,
+                    request
+                });
+            };
+        });
+    });
+    return Object.assign(client, {
+        __register: registerHandlers,
+        __toggle: (event, enabled, roomId)=>toggleHandler({
+                event,
+                enabled,
+                roomId
+            }),
+        emitEvent: dispatch
+    });
+};
+const createClient = (input)=>{
+    const client = createClientCore({
+        ast: input.ast
+    });
+    const register = (registry)=>{
+        const requestKey = input.requestKey ?? DEFAULT_REQUEST_KEY;
+        setClientRequest({
+            client,
+            registry,
+            requestKey
+        });
+        registry.onReceive((envelope, _ctx, next)=>{
+            client.emitEvent(buildClientEventEnvelope(envelope));
+            return next();
+        });
+    };
+    const moduleBase = {
+        name: input.name ?? 'client',
+        register
+    };
+    const moduleWithClient = Object.assign(moduleBase, client);
+    return moduleWithClient;
+};
+const createClientModule = (input)=>createClient(input);
+export { clientModule, createClient, createClientModule };