libmodulor 0.1.0 → 0.2.0

package/dist/esm/uc/policies/EverybodyUCPolicy.js

@@ -0,0 +1,22 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable } from 'inversify';
+import { defaultUCPolicyOutput } from './funcs.js';
+let EverybodyUCPolicy = class EverybodyUCPolicy {
+    async canBeExecutedPreAuth() {
+        return true;
+    }
+    async exec(_input) {
+        const out = defaultUCPolicyOutput();
+        out.allowed = true;
+        return out;
+    }
+};
+EverybodyUCPolicy = __decorate([
+    injectable()
+], EverybodyUCPolicy);
+export { EverybodyUCPolicy };

package/dist/esm/uc/policies/NobodyUCPolicy.d.ts

@@ -0,0 +1,7 @@
+import type { UCInput } from '../input.js';
+import type { UCOPIBase } from '../opi.js';
+import type { UCPolicy, UCPolicyInput, UCPolicyOutput } from '../policy.js';
+export declare class NobodyUCPolicy<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> implements UCPolicy<I, OPI0, OPI1> {
+    canBeExecutedPreAuth(): Promise<boolean>;
+    exec(_input: UCPolicyInput<I, OPI0, OPI1>): Promise<UCPolicyOutput>;
+}

package/dist/esm/uc/policies/NobodyUCPolicy.js

@@ -0,0 +1,22 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable } from 'inversify';
+import { defaultUCPolicyOutput } from './funcs.js';
+let NobodyUCPolicy = class NobodyUCPolicy {
+    async canBeExecutedPreAuth() {
+        return true;
+    }
+    async exec(_input) {
+        const out = defaultUCPolicyOutput();
+        out.allowed = false;
+        return out;
+    }
+};
+NobodyUCPolicy = __decorate([
+    injectable()
+], NobodyUCPolicy);
+export { NobodyUCPolicy };

package/dist/esm/uc/policies/RoleAdminUCPolicy.d.ts

@@ -0,0 +1,7 @@
+import type { UCInput } from '../input.js';
+import type { UCOPIBase } from '../opi.js';
+import type { UCPolicy, UCPolicyInput, UCPolicyOutput } from '../policy.js';
+export declare class RoleAdminUCPolicy<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> implements UCPolicy<I, OPI0, OPI1> {
+    canBeExecutedPreAuth(): Promise<boolean>;
+    exec({ uc, }: UCPolicyInput<I, OPI0, OPI1>): Promise<UCPolicyOutput>;
+}

package/dist/esm/uc/policies/RoleAdminUCPolicy.js

@@ -0,0 +1,22 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable } from 'inversify';
+import { defaultUCPolicyOutput } from './funcs.js';
+let RoleAdminUCPolicy = class RoleAdminUCPolicy {
+    async canBeExecutedPreAuth() {
+        return false;
+    }
+    async exec({ uc, }) {
+        const out = defaultUCPolicyOutput();
+        out.allowed = uc.auth?.role === 'admin';
+        return out;
+    }
+};
+RoleAdminUCPolicy = __decorate([
+    injectable()
+], RoleAdminUCPolicy);
+export { RoleAdminUCPolicy };

package/dist/esm/uc/policies/RoleRegularUCPolicy.d.ts

@@ -0,0 +1,7 @@
+import type { UCInput } from '../input.js';
+import type { UCOPIBase } from '../opi.js';
+import type { UCPolicy, UCPolicyInput, UCPolicyOutput } from '../policy.js';
+export declare class RoleRegularUCPolicy<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> implements UCPolicy<I, OPI0, OPI1> {
+    canBeExecutedPreAuth(): Promise<boolean>;
+    exec({ uc, }: UCPolicyInput<I, OPI0, OPI1>): Promise<UCPolicyOutput>;
+}

package/dist/esm/uc/policies/RoleRegularUCPolicy.js

@@ -0,0 +1,22 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable } from 'inversify';
+import { defaultUCPolicyOutput } from './funcs.js';
+let RoleRegularUCPolicy = class RoleRegularUCPolicy {
+    async canBeExecutedPreAuth() {
+        return false;
+    }
+    async exec({ uc, }) {
+        const out = defaultUCPolicyOutput();
+        out.allowed = uc.auth?.role === 'regular';
+        return out;
+    }
+};
+RoleRegularUCPolicy = __decorate([
+    injectable()
+], RoleRegularUCPolicy);
+export { RoleRegularUCPolicy };

package/dist/esm/uc/policies/funcs.d.ts

@@ -0,0 +1,2 @@
+import type { UCPolicyOutput } from '../policy.js';
+export declare function defaultUCPolicyOutput(): UCPolicyOutput;

package/dist/esm/uc/policies/funcs.js

@@ -0,0 +1,6 @@
+export function defaultUCPolicyOutput() {
+    const out = {
+        allowed: false,
+    };
+    return out;
+}

package/dist/esm/uc/policy.d.ts

@@ -0,0 +1,13 @@
+import type { Worker } from '../std/index.js';
+import type { UC } from './UC.js';
+import type { UCInput } from './input.js';
+import type { UCOPIBase } from './opi.js';
+export interface UCPolicyInput<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    uc: UC<I, OPI0, OPI1>;
+}
+export interface UCPolicyOutput {
+    allowed: boolean;
+}
+export interface UCPolicy<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> extends Worker<UCPolicyInput<I, OPI0, OPI1>, Promise<UCPolicyOutput>> {
+    canBeExecutedPreAuth(): Promise<boolean>;
+}

package/dist/esm/uc/policy.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/uc/sec/consts.d.ts

@@ -0,0 +1,3 @@
+import type { UCSecAuthType, UCSecPublicApiKeyCheckType } from '../sec.js';
+export declare const DEFAULT_UC_SEC_AT: UCSecAuthType;
+export declare const DEFAULT_UC_SEC_PAKCT: UCSecPublicApiKeyCheckType;

package/dist/esm/uc/sec/consts.js

@@ -0,0 +1,2 @@
+export const DEFAULT_UC_SEC_AT = 'jwt';
+export const DEFAULT_UC_SEC_PAKCT = 'on';

package/dist/esm/uc/sec.d.ts

@@ -0,0 +1,6 @@
+export type UCSecAuthType = 'apiKey' | 'basic' | 'jwt';
+export type UCSecPublicApiKeyCheckType = 'off' | 'on';
+export interface UCSec {
+    authType?: UCSecAuthType;
+    publicApiKeyCheckType?: UCSecPublicApiKeyCheckType;
+}

package/dist/esm/uc/sec.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/uc/server.d.ts

@@ -0,0 +1,13 @@
+import type { Class } from '../utils/index.js';
+import type { UCExecMode } from './exec.js';
+import type { UCInit } from './init.js';
+import type { UCInput } from './input.js';
+import type { UCMain } from './main.js';
+import type { UCOPIBase } from './opi.js';
+import type { UCPolicy } from './policy.js';
+export interface UCServerDef<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    execMode?: UCExecMode;
+    init?: Class<UCInit>;
+    main: Class<UCMain<I, OPI0, OPI1>>;
+    policy: Class<UCPolicy<I, OPI0, OPI1>>;
+}

package/dist/esm/uc/server.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/uc/settings/consts.d.ts

@@ -0,0 +1,2 @@
+import type { UCSettings } from '../settings.js';
+export declare const UC_DEFAULT_SETTINGS: UCSettings;

package/dist/esm/uc/settings/consts.js

@@ -0,0 +1,6 @@
+export const UC_DEFAULT_SETTINGS = {
+    uc_data_store_ucs_dataset_name: 'use-cases',
+    uc_disabled_use_cases: [],
+    uc_file_ref_prefix: '$ref:',
+    uc_files_directory_path: 'tmp',
+};

package/dist/esm/uc/settings.d.ts

@@ -0,0 +1,11 @@
+import type { FilePath } from '../dt/index.js';
+import type { Settings } from '../std/index.js';
+import type { UCDataStoreDatasetName } from './data-store.js';
+import type { UCFileInputFieldRefPrefix } from './file.js';
+import type { UCName } from './metadata.js';
+export interface UCSettings extends Settings {
+    uc_data_store_ucs_dataset_name: UCDataStoreDatasetName;
+    uc_disabled_use_cases: UCName[];
+    uc_file_ref_prefix: UCFileInputFieldRefPrefix;
+    uc_files_directory_path: FilePath;
+}

package/dist/esm/uc/settings.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/uc/side-effect.d.ts

@@ -0,0 +1,12 @@
+export declare enum UCOutputSideEffectType {
+    CLEAR_AUTH = "CLEAR_AUTH",
+    REDIRECT = "REDIRECT",
+    SET_AUTH = "SET_AUTH"
+}
+export type UCOutputSideEffect = {
+    type: UCOutputSideEffectType.CLEAR_AUTH;
+} | {
+    type: UCOutputSideEffectType.REDIRECT;
+} | {
+    type: UCOutputSideEffectType.SET_AUTH;
+};

package/dist/esm/uc/side-effect.js

@@ -0,0 +1,6 @@
+export var UCOutputSideEffectType;
+(function (UCOutputSideEffectType) {
+    UCOutputSideEffectType["CLEAR_AUTH"] = "CLEAR_AUTH";
+    UCOutputSideEffectType["REDIRECT"] = "REDIRECT";
+    UCOutputSideEffectType["SET_AUTH"] = "SET_AUTH";
+})(UCOutputSideEffectType || (UCOutputSideEffectType = {}));

package/dist/esm/uc/transporter.d.ts

@@ -0,0 +1,7 @@
+import type { UC } from './UC.js';
+import type { UCInput } from './input.js';
+import type { UCOPIBase } from './opi.js';
+import type { UCOutputOrNothing } from './output.js';
+export interface UCTransporter {
+    send<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): Promise<UCOutputOrNothing<OPI0, OPI1>>;
+}

package/dist/esm/uc/transporter.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/uc/utils/appendUCInputToURL.d.ts

@@ -0,0 +1,4 @@
+import type { UC } from '../UC.js';
+import type { UCInput } from '../input.js';
+import type { UCOPIBase } from '../opi.js';
+export declare function appendUCInputToURL<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>, url: URL): void;

package/dist/esm/uc/utils/appendUCInputToURL.js

@@ -0,0 +1,12 @@
+import { rInput } from './rInput.js';
+export function appendUCInputToURL(uc, url) {
+    const data = rInput(uc, { ignoreUndefined: true });
+    for (const [key, value] of Object.entries(data)) {
+        const isArray = Array.isArray(value);
+        const keyToSend = isArray ? `${key}[]` : key;
+        const valueToSend = isArray ? value : [value];
+        for (const v of valueToSend) {
+            url.searchParams.append(keyToSend, v);
+        }
+    }
+}

package/dist/esm/uc/utils/fmtVal.d.ts

@@ -0,0 +1,7 @@
+import type { DataType } from '../../dt/index.js';
+import type { WordingManager } from '../../i18n/index.js';
+import type { UCInputField } from '../UCInputField.js';
+import type { UCOutputField } from '../UCOutputField.js';
+import type { UCOPIBase } from '../opi.js';
+export declare function fmtInputVal<T extends DataType>(wordingManager: WordingManager, field: UCInputField<T>, ifNullOrUndefined?: string | undefined): [string, string | null, string];
+export declare function fmtOPIVal<OPI extends UCOPIBase, T extends DataType>(wordingManager: WordingManager, field: UCOutputField<OPI, T>, item: OPI | null, ifNullOrUndefined?: string | undefined): [string, string | null, string];

package/dist/esm/uc/utils/fmtVal.js

@@ -0,0 +1,20 @@
+function fmtVal(wordingManager, label, type, value, ifNullOrUndefined) {
+    type.assign(value);
+    let desc = null;
+    let val = type.fmt(ifNullOrUndefined);
+    if (type.hasOptions()) {
+        const { desc: tDesc, label: tLabel } = wordingManager.dt(type);
+        desc = tDesc;
+        val = tLabel;
+    }
+    type.clear();
+    return [label, desc, val];
+}
+export function fmtInputVal(wordingManager, field, ifNullOrUndefined) {
+    const { label } = wordingManager.ucif(field);
+    return fmtVal(wordingManager, label, field.def.type, field.getValue(), ifNullOrUndefined);
+}
+export function fmtOPIVal(wordingManager, field, item, ifNullOrUndefined) {
+    const { label } = wordingManager.ucof(field.key);
+    return fmtVal(wordingManager, label, field.def.type, item?.[field.key], ifNullOrUndefined);
+}

package/dist/esm/uc/utils/rInput.d.ts

@@ -0,0 +1,11 @@
+import type { UC } from '../UC.js';
+import type { UCInput } from '../input.js';
+import type { UCOPIBase } from '../opi.js';
+interface Opts {
+    forceArrayAsEmpty?: boolean | undefined;
+    forceBooleanAsFalse?: boolean | undefined;
+    ignoreTransient?: boolean | undefined;
+    ignoreUndefined?: boolean | undefined;
+}
+export declare function rInput<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>, opts?: Opts): NonNullable<I>;
+export {};

package/dist/esm/uc/utils/rInput.js

@@ -0,0 +1,39 @@
+import { TBoolean } from '../../dt/index.js';
+import { ucifIsMandatory, ucifRepeatability } from '../input-field.js';
+const DEFAULT_OPTS = {
+    forceArrayAsEmpty: false,
+    forceBooleanAsFalse: true,
+    ignoreTransient: false,
+    ignoreUndefined: false,
+};
+export function rInput(uc, opts) {
+    const forceArrayAsEmpty = opts?.forceArrayAsEmpty ?? DEFAULT_OPTS.forceArrayAsEmpty;
+    const forceBooleanAsFalse = opts?.forceBooleanAsFalse ?? DEFAULT_OPTS.forceBooleanAsFalse;
+    const ignoreTransient = opts?.ignoreTransient ?? DEFAULT_OPTS.ignoreTransient;
+    const ignoreUndefined = opts?.ignoreUndefined ?? DEFAULT_OPTS.ignoreUndefined;
+    const input = {};
+    let fields = uc.inputFields;
+    if (ignoreTransient) {
+        fields = fields.filter((f) => f.def.transient !== true);
+    }
+    for (const f of fields) {
+        const { type } = f.def;
+        let value = f.getValue();
+        if (forceBooleanAsFalse &&
+            type instanceof TBoolean &&
+            ucifIsMandatory(f.def) &&
+            (value === null || value === undefined)) {
+            value = false;
+        }
+        const [isRepeatable] = ucifRepeatability(f.def);
+        if (forceArrayAsEmpty &&
+            isRepeatable &&
+            (value === null || value === undefined)) {
+            value = [];
+        }
+        if (!ignoreUndefined || (ignoreUndefined && value !== undefined)) {
+            input[f.key] = value;
+        }
+    }
+    return input;
+}

package/dist/esm/uc/utils/rVal.d.ts

@@ -0,0 +1,5 @@
+import type { DataType } from '../../dt/index.js';
+import type { Value } from '../value.js';
+export declare function rVal0<T extends DataType>(value: Value<T>, or?: T): T | null;
+export declare function reqVal0<T extends DataType>(value: Value<T>): T;
+export declare function rValArr<T extends DataType>(value: Value<T>): T[];

package/dist/esm/uc/utils/rVal.js

@@ -0,0 +1,20 @@
+import { isBlank } from '../../utils/index.js';
+export function rVal0(value, or) {
+    if (isBlank(value)) {
+        return or ?? null;
+    }
+    return Array.isArray(value) ? (value[0] ?? null) : value;
+}
+export function reqVal0(value) {
+    const val = rVal0(value);
+    if (isBlank(val)) {
+        throw new Error('The value is blank');
+    }
+    return val;
+}
+export function rValArr(value) {
+    if (isBlank(value)) {
+        return [];
+    }
+    return Array.isArray(value) ? value : [value];
+}

package/dist/esm/uc/utils/recIs.d.ts

@@ -0,0 +1,5 @@
+import type { UCDataStoreRecord } from '../data-store.js';
+import type { UCData } from '../data.js';
+import type { UCInput } from '../input.js';
+import type { UCName } from '../metadata.js';
+export declare const recIs: <I extends UCInput | undefined = undefined, D extends UCData | null = null>(rec: UCDataStoreRecord<any, any>, name: UCName) => rec is UCDataStoreRecord<I, D>;

package/dist/esm/uc/utils/recIs.js

@@ -0,0 +1 @@
+export const recIs = (rec, name) => rec.name === name;

package/dist/esm/uc/utils/stripUCDLifecycleServer.d.ts

@@ -0,0 +1,2 @@
+import type { UCDefSourceRaw } from '../def.js';
+export declare function stripUCDLifecycleServer(source: UCDefSourceRaw): UCDefSourceRaw;

package/dist/esm/uc/utils/stripUCDLifecycleServer.js

@@ -0,0 +1,60 @@
+import { UC_MAIN_SERVER_SUFFIX } from '../../convention.js';
+const CORE_SERVER_MAINS = ['IdleServerMain'];
+const TOKEN_IMPORT = 'import';
+const TOKEN_IMPORT_END = ';';
+const TOKEN_LIFECYCLE_SERVER = 'server: {';
+const TOKEN_LIFECYCLE_SERVER_END = '},';
+const TOKEN_LIFECYCLE_SERVER_REPLACE = 'server: true,';
+export function stripUCDLifecycleServer(source) {
+    const occurrences = [
+        ...source.matchAll(new RegExp(UC_MAIN_SERVER_SUFFIX, 'g')),
+    ];
+    const count = occurrences.length;
+    const toReplace = [];
+    let occIdx = 0;
+    for (const occ of occurrences) {
+        if (count === 3 && occIdx === 1) {
+            occIdx += 1;
+            continue;
+        }
+        const toRep = { end: 0, start: 0, str: '' };
+        let cursor = occ.index;
+        let expr = '';
+        while (!expr.startsWith(TOKEN_IMPORT) &&
+            !expr.startsWith(TOKEN_LIFECYCLE_SERVER)) {
+            expr = `${source[cursor]}${expr}`;
+            cursor -= 1;
+        }
+        toRep.start = cursor;
+        cursor = occ.index;
+        while (!expr.endsWith(TOKEN_IMPORT_END) &&
+            !expr.endsWith(TOKEN_LIFECYCLE_SERVER_END)) {
+            expr = `${expr}${source[cursor]}`;
+            cursor += 1;
+        }
+        toRep.end = cursor;
+        toRep.str = source.substring(toRep.start, toRep.end).trim();
+        toReplace.push(toRep);
+        occIdx += 1;
+    }
+    toReplace.reverse();
+    let cleaned = source;
+    for (const { str } of toReplace) {
+        if (str.startsWith(TOKEN_LIFECYCLE_SERVER)) {
+            cleaned = cleaned.replaceAll(str, TOKEN_LIFECYCLE_SERVER_REPLACE);
+            continue;
+        }
+        if (str.startsWith(TOKEN_IMPORT)) {
+            for (const coreServerMain of CORE_SERVER_MAINS) {
+                if (str.includes(coreServerMain)) {
+                    cleaned = cleaned.replace(new RegExp(`${coreServerMain},?`), '');
+                }
+            }
+            cleaned = cleaned.replaceAll(str, '');
+        }
+    }
+    if (cleaned.includes(UC_MAIN_SERVER_SUFFIX)) {
+        throw new Error(`Stripping UCD server lifecycle did not complete successfully. The output still contains references to ${UC_MAIN_SERVER_SUFFIX} : ${cleaned}`);
+    }
+    return cleaned;
+}

package/dist/esm/uc/utils/ucHTTPContract.d.ts

@@ -0,0 +1,14 @@
+import type { HTTPContentType, HTTPMethod, URLPath } from '../../dt/index.js';
+import type { HTTPDataEnvelope } from '../../utils/index.js';
+import type { UC } from '../UC.js';
+import type { UCInput } from '../input.js';
+import type { UCOPIBase } from '../opi.js';
+import { type UCMountingPoint } from './ucMountingPoint.js';
+export interface UCHTTPContract {
+    contentType: HTTPContentType;
+    envelope: HTTPDataEnvelope;
+    method: HTTPMethod;
+    mountingPoint: UCMountingPoint;
+    path: URLPath;
+}
+export declare function ucHTTPContract<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>, pathPrefix?: `/${URLPath}`): UCHTTPContract;

package/dist/esm/uc/utils/ucHTTPContract.js

@@ -0,0 +1,34 @@
+import { ucMountingPoint } from './ucMountingPoint.js';
+const ACTION_HTTP_METHOD_MAPPING = {
+    Create: 'POST',
+    Delete: 'DELETE',
+    List: 'GET',
+    Search: 'POST',
+    Update: 'PUT',
+    View: 'GET',
+};
+const METHODS_WITH_NO_BODY = ['GET'];
+export function ucHTTPContract(uc, pathPrefix = '/api/v1') {
+    const { ext, metadata } = uc.def;
+    const { action } = metadata;
+    const hasMediaInInput = uc.hasMediaInInput();
+    const contentType = hasMediaInInput
+        ? 'multipart/form-data'
+        : 'application/json';
+    const method = ext?.http?.method ?? ACTION_HTTP_METHOD_MAPPING[action];
+    let envelope = METHODS_WITH_NO_BODY.includes(method)
+        ? 'query-params'
+        : 'json';
+    if (hasMediaInInput) {
+        envelope = 'form-data';
+    }
+    const mountingPoint = ucMountingPoint(uc);
+    const path = ext?.http?.mountAt ?? `${pathPrefix}/${mountingPoint}`;
+    return {
+        contentType,
+        envelope,
+        method,
+        mountingPoint,
+        path,
+    };
+}

package/dist/esm/uc/utils/ucMountingPoint.d.ts

@@ -0,0 +1,7 @@
+import type { UC } from '../UC.js';
+import type { UCInput } from '../input.js';
+import { type FQUCName, parseFQUCName } from '../metadata.js';
+import type { UCOPIBase } from '../opi.js';
+export type UCMountingPoint = FQUCName | (string & {});
+export declare function ucMountingPoint<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): UCMountingPoint;
+export declare function parseUCMountingPoint(value: string): ReturnType<typeof parseFQUCName>;

package/dist/esm/uc/utils/ucMountingPoint.js

@@ -0,0 +1,7 @@
+import { formatFQUCName, parseFQUCName } from '../metadata.js';
+export function ucMountingPoint(uc) {
+    return formatFQUCName(uc.appManifest.name, uc.def.metadata.name);
+}
+export function parseUCMountingPoint(value) {
+    return parseFQUCName(value);
+}

package/dist/esm/uc/utils/ucifcoIsForArray.d.ts

@@ -0,0 +1,2 @@
+import { UCInputFieldChangeOperator } from '../input-field.js';
+export declare function ucifcoIsForArray(op: UCInputFieldChangeOperator): op is UCInputFieldChangeOperator.ADD | UCInputFieldChangeOperator.REMOVE;

package/dist/esm/uc/utils/ucifcoIsForArray.js

@@ -0,0 +1,7 @@
+import { UCInputFieldChangeOperator } from '../input-field.js';
+export function ucifcoIsForArray(op) {
+    return [
+        UCInputFieldChangeOperator.ADD,
+        UCInputFieldChangeOperator.REMOVE,
+    ].includes(op);
+}

package/dist/esm/uc/value.d.ts

@@ -0,0 +1,2 @@
+import type { DataType } from '../dt/index.js';
+export type Value<T extends DataType> = T | T[] | null | undefined;

package/dist/esm/uc/value.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/uc/workers/SimpleAggregateFinder.d.ts

@@ -0,0 +1,20 @@
+import type { UUID } from '../../dt/index.js';
+import type { Worker } from '../../std/index.js';
+import type { UCDataStore, UCDataStoreRecord } from '../data-store.js';
+import type { UCData } from '../data.js';
+import type { UCInput } from '../input.js';
+import type { UCMetadata } from '../metadata.js';
+interface Input {
+    add: UCMetadata;
+    aggregateId: UUID;
+    remove: UCMetadata[];
+}
+interface Output<I extends UCInput | undefined = undefined, D extends UCData | null = null> {
+    record: UCDataStoreRecord<I, D>;
+}
+export declare class SimpleAggregateFinder implements Worker<Input, Promise<Output>> {
+    private ucDataStore;
+    constructor(ucDataStore: UCDataStore);
+    exec<I extends UCInput | undefined = undefined, D extends UCData | null = null>({ add, aggregateId, remove }: Input): Promise<Output<I, D>>;
+}
+export {};

package/dist/esm/uc/workers/SimpleAggregateFinder.js

@@ -0,0 +1,45 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+import { NotFoundError } from '../../error/index.js';
+let SimpleAggregateFinder = class SimpleAggregateFinder {
+    ucDataStore;
+    constructor(ucDataStore) {
+        this.ucDataStore = ucDataStore;
+    }
+    async exec({ add, aggregateId, remove }) {
+        const { records } = await this.ucDataStore.read({
+            filters: {
+                aggregateId,
+                name: [add.name, ...remove.map((r) => r.name)],
+            },
+        });
+        if (records.length > 1) {
+            throw new NotFoundError();
+        }
+        if (records.length === 0) {
+            throw new NotFoundError();
+        }
+        const record = records[0];
+        if (!record) {
+            throw new NotFoundError();
+        }
+        return { record };
+    }
+};
+SimpleAggregateFinder = __decorate([
+    injectable(),
+    __param(0, inject('UCDataStore')),
+    __metadata("design:paramtypes", [Object])
+], SimpleAggregateFinder);
+export { SimpleAggregateFinder };

package/dist/esm/uc/workers/SimpleAggregateOwnershipChecker.d.ts

@@ -0,0 +1,17 @@
+import type { Worker } from '../../std/index.js';
+import type { UC } from '../UC.js';
+import type { UCDataStoreRecord } from '../data-store.js';
+import type { UCData } from '../data.js';
+import type { UCInput } from '../input.js';
+type OwnershipScope = 'organization' | 'user';
+interface Input<I extends UCInput | undefined = undefined, D extends UCData | null = null> {
+    record: UCDataStoreRecord<I, D>;
+    scope?: OwnershipScope[];
+    uc: UC<any, any, any>;
+}
+export declare class SimpleAggregateOwnershipChecker implements Worker<Input, Promise<void>> {
+    exec<I extends UCInput | undefined = undefined, D extends UCData | null = null>({ record, scope, uc, }: Input<I, D>): Promise<void>;
+    private checkOrg;
+    private checkUser;
+}
+export {};