@weclapp/sdk 1.8.0-dev.16

package/dist/cli.js

@@ -0,0 +1,1397 @@
+import { fileURLToPath } from 'url';
+import { resolve, dirname } from 'path';
+import { rmdir, stat, readFile, writeFile, rm, cp, mkdir } from 'fs/promises';
+import { rollup } from 'rollup';
+import terser from '@rollup/plugin-terser';
+import ts from 'rollup-plugin-ts';
+import indentString from 'indent-string';
+import { snakeCase, pascalCase, camelCase } from 'change-case';
+import chalk from 'chalk';
+import { OpenAPIV3 } from 'openapi-types';
+import { createHash } from 'crypto';
+import { config } from 'dotenv';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import prettyMs from 'pretty-ms';
+
+var Target;
+(function (Target) {
+    Target["BROWSER_PROMISES"] = "browser";
+    Target["BROWSER_RX"] = "browser.rx";
+    Target["NODE_PROMISES"] = "node";
+    Target["NODE_RX"] = "node.rx";
+})(Target || (Target = {}));
+const isNodeTarget = (target) => {
+    return target === Target.NODE_PROMISES || target === Target.NODE_RX;
+};
+const isRXTarget = (target) => {
+    return target === Target.BROWSER_RX || target === Target.NODE_RX;
+};
+const resolveResponseType = (target) => {
+    return isRXTarget(target) ? 'Observable' : 'Promise';
+};
+const resolveBinaryType = (target) => {
+    return isNodeTarget(target) ? 'Buffer' : 'Blob';
+};
+
+const currentDirname = () => {
+    // Go one level up as the CLI is inside a folder
+    return fileURLToPath(new URL('..', import.meta.url));
+};
+
+const tsconfig = resolve(currentDirname(), './tsconfig.lib.json');
+const resolveGlobals = (...globals) => Object.fromEntries(globals.map(v => [v, '*']));
+const generateOutput = (config) => ({
+    sourcemap: true,
+    banner: `/* weclapp sdk */`,
+    ...config
+});
+const bundle = async (workingDirectory, target) => {
+    const dist = (...paths) => resolve(workingDirectory, 'dist', ...paths);
+    const src = (...paths) => resolve(workingDirectory, 'src', ...paths);
+    const generateNodeOutput = () => [
+        generateOutput({
+            file: dist('index.cjs'),
+            format: 'cjs',
+            globals: resolveGlobals('node-fetch', 'url')
+        }),
+        generateOutput({
+            file: dist('index.js'),
+            format: 'es',
+            globals: resolveGlobals('node-fetch', 'url')
+        })
+    ];
+    // Remove build dir
+    await rmdir(dist()).catch(() => void 0);
+    const bundles = {
+        [Target.BROWSER_PROMISES]: () => ({
+            input: src('browser.ts'),
+            output: [
+                generateOutput({
+                    file: dist('index.cjs'),
+                    name: 'Weclapp',
+                    format: 'umd'
+                }),
+                generateOutput({
+                    file: dist('index.js'),
+                    format: 'es'
+                })
+            ],
+            plugins: [ts({ tsconfig }), terser()]
+        }),
+        [Target.BROWSER_RX]: () => ({
+            external: ['rxjs'],
+            input: src('browser.rx.ts'),
+            plugins: [ts({ tsconfig }), terser()],
+            output: [
+                generateOutput({
+                    file: dist('index.cjs'),
+                    name: 'Weclapp',
+                    format: 'umd',
+                    globals: resolveGlobals('rxjs')
+                }),
+                generateOutput({
+                    file: dist('index.js'),
+                    format: 'es',
+                    globals: resolveGlobals('rxjs')
+                })
+            ]
+        }),
+        [Target.NODE_PROMISES]: () => ({
+            input: src('node.ts'),
+            output: generateNodeOutput(),
+            external: ['node-fetch', 'url'],
+            plugins: [ts({ tsconfig })]
+        }),
+        [Target.NODE_RX]: () => ({
+            input: src('node.rx.ts'),
+            output: generateNodeOutput(),
+            external: ['node-fetch', 'url', 'rxjs'],
+            plugins: [ts({ tsconfig })]
+        })
+    };
+    const config = bundles[target]();
+    const bundle = await rollup(config);
+    if (Array.isArray(config.output)) {
+        await Promise.all(config.output.map(bundle.write));
+    }
+    else if (config.output) {
+        await bundle.write(config.output);
+    }
+    await bundle.close();
+};
+
+const generateString = (str) => `'${str}'`;
+const generateStrings = (str) => str.map(generateString);
+
+const generateImport = (opt) => {
+    const imports = [opt.default, opt.imports?.length ? `{${opt.imports.join(', ')}}` : ''];
+    return `import ${imports.filter(Boolean).join(', ')} from ${generateString(opt.src)};`;
+};
+
+/**
+ * Indents each line of the given string
+ * @param s String to indent
+ * @param level Indentation level
+ */
+const indent = (s, level = 1) => {
+    return indentString(s, 4 * level);
+};
+
+const generateStatements = (...statements) => statements
+    .map(v => v.trim())
+    .filter(v => v.length)
+    .join('\n\n');
+const generateBlockStatements = (...statements) => `{\n${indent(generateStatements(...statements))}\n}`;
+
+var root = "export type RequestPayloadMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH';\n\nexport interface RequestPayload {\n    method?: RequestPayloadMethod;\n    query?: Record<string, any>;\n    body?: any;\n    unwrap?: boolean;\n    forceBlob?: boolean;\n}\n\nexport interface ServiceConfig {\n\n    // Your API-Key, this is optional in the sense of if you omit this, and you're in a browser, the\n    // cookie-authentication (include-credentials) will be used.\n    key?: string;\n\n    // Your domain, if omitted location.host will be used.\n    host?: string;\n\n    // If you want to use https, defaults to true.\n    secure?: boolean;\n\n    // Optional request/response interceptors.\n    interceptors?: {\n\n        // Takes the generated request, you can either return a new request,\n        // a response (which will be taken as \"the\" response) or nothing.\n        // The payload contains the raw input generated by the SDK.\n        request?: (request: Request, payload: RequestPayload) => Request | Response | void | Promise<Request | Response | void>;\n\n        // Takes the response. This can either be the one from the server or an\n        // artificially-crafted one by the request interceptor.\n        response?: (response: Response) => Response | void | Promise<Response | void>;\n    };\n}\n\nlet globalConfig: ServiceConfig | undefined;\nexport const getGlobalConfig = (): ServiceConfig | undefined => globalConfig;\nexport const setGlobalConfig = (cfg?: ServiceConfig) => globalConfig = cfg;\n\nexport const raw = async (\n    cfg: ServiceConfig | undefined = globalConfig,\n    endpoint: string,\n    payload: RequestPayload = {}\n): Promise<any> => {\n    if (!cfg) {\n        throw new Error(`ServiceConfig missing.`);\n    }\n\n    cfg = {\n        ...globalConfig, ...cfg,\n        interceptors: {...globalConfig?.interceptors, ...cfg?.interceptors}\n    };\n\n    const isBinaryData = payload.body instanceof resolveBinaryObject();\n    const params = new URLSearchParams(Object.entries(payload.query ?? {}).filter(v => v[1] !== undefined));\n    const protocol = (cfg.secure ?? true) ? 'https' : 'http';\n\n    const interceptRequest = cfg.interceptors?.request ?? (v => v);\n    const interceptResponse = cfg.interceptors?.response ?? (v => v);\n\n    let host = cfg.host?.replace(/^https?:\\/\\//, '');\n    if (!host && typeof location !== 'undefined') {\n        host = location.host;\n    }\n\n    if (!host) {\n        throw new Error('Please specify a domain');\n    }\n\n    const request = new Request(`${protocol}://${host}/webapp/api/v1${endpoint}?${params}`, {\n        ...(payload.body && {\n            body: isBinaryData\n                ? payload.body\n                : JSON.stringify(payload.body, (key, value) => value === undefined ? null : value)\n        }),\n        ...(!cfg.key && {credentials: 'same-origin'}),\n        method: payload.method ?? 'get',\n        headers: {\n            'Accept': 'application/json',\n            ...(cfg.key && {'AuthenticationToken': cfg.key}),\n            ...(!isBinaryData && {'Content-Type': 'application/json'})\n        }\n    });\n\n    let res = await interceptRequest(request, payload) ?? request;\n    if (!(res instanceof Response)) {\n        res = await fetch(res);\n    }\n\n    res = await interceptResponse(res) ?? res;\n    const data = (!payload.forceBlob || !res.ok) && res.headers?.get('content-type')?.includes('application/json') ?\n        await res.json() : await res.blob();\n\n    // Check if response was successful\n    if (!res.ok) {\n        return Promise.reject(data);\n    }\n\n    return payload.unwrap ? data.result : data;\n};\n\nconst _count = (\n    cfg: ServiceConfig | undefined,\n    endpoint: string,\n    query?: CountQuery<any> & {params?: Record<any, any>}\n) => wrapResponse(() => raw(cfg, endpoint, {\n    unwrap: true,\n    query: {\n        ...flattenFilter(query?.filter),\n        ...flattenOrFilter(query?.or),\n        ...query?.params\n    }\n}));\n\nconst _some = (\n    cfg: ServiceConfig | undefined,\n    endpoint: string,\n    query?: SomeQuery<any, any, any, any> & {params?: Record<any, any>}\n) => wrapResponse(() => raw(cfg, endpoint, {\n        query: {\n            serializeNulls: query?.serializeNulls,\n            properties: query?.select ? flattenSelect(query.select).join(',') : undefined,\n            includeReferencedEntities: query?.include ? Object.keys(query.include).join(',') : undefined,\n            ...flattenOrFilter(query?.or),\n            ...flattenFilter(query?.filter),\n            ...flattenSort(query?.sort),\n            ...query?.params,\n            ...query?.pagination\n        }\n    }).then(data => ({entities: data.result, references: data.referencedEntities ?? {}}))\n);\n\nconst _remove = (\n    cfg: ServiceConfig | undefined,\n    endpoint: string\n) => wrapResponse(() => raw(cfg, endpoint, {\n    method: 'DELETE'\n}).then(() => undefined));\n\nconst _create = (\n    cfg: ServiceConfig | undefined,\n    endpoint: string,\n    data: any\n) => wrapResponse(() => raw(cfg, endpoint, {\n    method: 'POST',\n    body: data\n}));\n\nconst _update = (\n    cfg: ServiceConfig | undefined,\n    endpoint: string,\n    data: any,\n    {ignoreMissingProperties = true}: UpdateQuery = {}\n) => wrapResponse(() => raw(cfg, endpoint, {\n    method: 'PUT',\n    body: data,\n    query: {ignoreMissingProperties}\n}));\n\nconst _unique = (\n    cfg: ServiceConfig | undefined,\n    endpoint: string,\n    query?: UniqueQuery\n) => wrapResponse(() => raw(cfg, endpoint, {query}));\n\nconst _generic = (\n    cfg: ServiceConfig | undefined,\n    method: RequestPayloadMethod,\n    endpoint: string,\n    payload?: GenericQuery<any, any>,\n    forceBlob?: boolean\n) => wrapResponse(() => raw(cfg, endpoint, {\n    method,\n    forceBlob,\n    body: payload?.body,\n    query: payload?.params\n}));\n";
+
+var types$1 = "export type DeepPartial<T> = T extends object ? {\n    [P in keyof T]?: DeepPartial<T[P]>;\n} : T;\n\n// Filter properties\nexport type EqualityOperators = 'EQ' | 'NE';\nexport type ComparisonOperators = 'LT' | 'GT' | 'LE' | 'GE' | 'LIKE' | 'ILIKE' | 'NOT_LIKE' | 'NOT_ILIKE';\nexport type ArrayOperators = 'IN' | 'NOT_IN';\nexport type Operator = EqualityOperators | ComparisonOperators | ArrayOperators;\n\nexport type MapOperators<T> = { [K in EqualityOperators]?: T | null; } &\n    { [K in ComparisonOperators]?: T; } &\n    { [K in ArrayOperators]?: T[]; };\n\nexport type QueryFilter<T> = {\n    [P in keyof T]?:\n        T[P] extends Array<infer U> | undefined ?\n            U extends Record<any, any> ? QueryFilter<U> : MapOperators<U> :\n                T[P] extends Record<any, any> | undefined ? QueryFilter<T[P]> : MapOperators<T[P]>;\n};\n\nexport type Sort<T> = {\n    [K in keyof T]?: {\n        [V in keyof T]?:\n            V extends K ?\n                T[V] extends Array<infer U> | undefined ?\n                    U extends object ?\n                        Sort<U> : never :\n                            T[V] extends object | undefined ?\n                                Sort<T[V]> : 'asc' | 'desc' : never;\n    };\n}[keyof T];\n\n// Select properties\nexport type CustomAttributeFilter = {\n    [K in number]: string | number | boolean |\n    {id: string;} |\n    {entityName: string; entityId: string;};\n}\n\nexport type QuerySelect<T> = {\n    [P in keyof T]?:\n        T[P] extends Array<infer U> | undefined ? (QuerySelect<U> | boolean) :\n            T[P] extends Record<any, any> | undefined ? (QuerySelect<T[P]> | boolean) : boolean;\n}\n\nexport type Select<T, Q extends (QuerySelect<T> | undefined)> = Q extends QuerySelect<T> ? {\n\n    // Filter out excluded properties beforehand\n    [P in keyof T as Q[P] extends boolean ? P : Q[P] extends object ? P : never]:\n\n    // Property\n    Q[P] extends true ? T[P] :\n\n        // Array\n        T[P] extends Array<infer U> ? Select<U, Q[P] & QuerySelect<any>>[] :\n\n            // Object\n            T[P] extends Record<any, any> ? Select<T[P], Q[P] & QuerySelect<any>> : never\n} : undefined;\n\nexport type MapKeys<T, S extends Record<keyof T, string>> = {\n    [K in keyof T as S[K]]: T[K];\n};\n\n// Endpoint configurations\nexport type CountQuery<F> = {\n    filter?: QueryFilter<F>;\n    or?: (QueryFilter<F> & CustomAttributeFilter)[];\n};\n\nexport type Pagination = {\n    page: number;\n    pageSize: number;\n};\n\nexport type SomeQuery<\n    E, // Entity\n    F, // Entity filter\n    I extends (QuerySelect<any> | undefined), // Select for referenced entities\n    S extends (QuerySelect<any> | undefined) // Select for entity properties\n> = {\n    serializeNulls?: boolean;\n    include?: I;\n    filter?: QueryFilter<F> & CustomAttributeFilter;\n    select?: S;\n    or?: (QueryFilter<F> & CustomAttributeFilter)[];\n    sort?: Sort<E>[];\n    pagination?: Pagination;\n};\n\nexport type UniqueQuery = {\n    serializeNulls?: boolean;\n}\n\nexport type SomeQueryReturn<\n    E, // Entity\n    R, // Map of referenced-entity names to the type\n    M, // Map of referenced-entity-id names to their entity name\n    I extends (QuerySelect<any> | undefined), // Select for referenced entities\n    S extends (QuerySelect<any> | undefined) // Select for entity properties\n> = {\n    entities: (S extends QuerySelect<E> ? Select<E, S> : E)[];\n    references: I extends QuerySelect<R> ? Partial<MapKeys<Select<R, I>, M & Record<any, any>>> : {};\n};\n\nexport type GenericQuery<P, B> = {\n    params?: P;\n    body?: B;\n};\n\nexport type UpdateQuery = {\n    ignoreMissingProperties?: boolean;\n}\n\n// Entity meta types\nexport type WEntityPropertyMeta = (\n    { type: 'string'; format?: 'decimal' | 'html'; entity?: WEntity; service?: WService; } |\n    { type: 'integer'; format: 'int32' | 'int64' | 'duration' | 'date' | 'timestamp'; } |\n    { type: 'array'; format: 'reference'; entity: WEntity; service?: WService; } |\n    { type: 'array'; format: 'reference'; enum: WEnum; } |\n    { type: 'array'; format: 'string'; } |\n    { type: 'number'; format: 'double'; } |\n    { type: 'reference'; entity: WEntity; } |\n    { type: 'reference'; enum: WEnum; } |\n    { type: 'boolean'; } |\n    { type: 'object'; }\n);\n\n// Utils\nconst equality: string[] = ['EQ', 'NE'];\nconst simple: string[] = [...equality, 'LT', 'GT', 'LE', 'GE', 'LIKE', 'NOT_LIKE', 'ILIKE', 'NOT_ILIKE'];\nconst array: string[] = ['IN', 'NOT_IN'];\nconst filterMap: Record<Operator, string> = {\n    EQ: 'eq',\n    NE: 'ne',\n    LT: 'lt',\n    GT: 'gt',\n    LE: 'le',\n    GE: 'ge',\n    LIKE: 'like',\n    NOT_LIKE: 'notlike',\n    ILIKE: 'ilike',\n    NOT_ILIKE: 'notilike',\n    IN: 'in',\n    NOT_IN: 'notin'\n};\n\nconst flattenCustomAttributes = (obj: CustomAttributeFilter = {}): [string, string][] => {\n    const entries: [string, string][] = [];\n\n    for (const [id, filter] of Object.entries(obj)) {\n        const key = `customAttribute${id}`;\n\n        if (typeof filter === 'object') {\n            for (const [prop, value] of Object.entries(filter)) {\n                entries.push([`${key}.${prop}-eq`, String(value)]);\n            }\n        } else if (filter !== undefined) {\n            entries.push([`${key}-eq`, String(filter)]);\n        }\n    }\n\n    return entries;\n};\n\nconst flatten = (obj: QueryFilter<any> = {}): [string, string][] => {\n    const entries: [string, string][] = [];\n\n    for (const [prop, propValue] of Object.entries(obj)) {\n        for (const [filter, value] of Object.entries(propValue as object)) {\n            if (value === undefined) continue;\n\n            if (simple.includes(filter)) {\n                if (value === null && equality.includes(filter)) {\n                    entries.push([`${prop}-${filter === 'EQ' ? 'null' : 'notnull'}`, '']);\n                } else {\n                    entries.push([`${prop}-${filterMap[filter as Operator]}`, value]);\n                }\n            } else if (array.includes(filter)) {\n                entries.push([\n                    `${prop}-${filterMap[filter as Operator]}`,\n                    `[${value.map((v: string | number) => typeof v === 'string' ? `\"${v}\"` : v)}]`\n                ]);\n            } else {\n                entries.push(\n                    ...flatten(propValue as QueryFilter<any>)\n                        .map(v => [`${prop}.${v[0]}`, v[1]]) as [string, string][]\n                );\n                break;\n            }\n        }\n    }\n\n    return entries;\n};\n\nconst flattenFilter = (obj: QueryFilter<any> = {}): Record<string, string> => {\n    const filter: [string, any][] = [], customAttributes: [string, any][] = [];\n\n    Object.entries(obj).forEach(value => {\n        (value[0].match(/^\\d+$/) ? customAttributes : filter).push(value);\n    });\n\n    return Object.fromEntries([\n        ...flatten(Object.fromEntries(filter)),\n        ...flattenCustomAttributes(Object.fromEntries(customAttributes) as CustomAttributeFilter)\n    ]);\n};\n\nconst flattenOrFilter = (obj: QueryFilter<any>[] = []): Record<string, string> => {\n    const entries: [string, any][] = [];\n\n    for (let i = 0; i < obj.length; i++) {\n        entries.push(\n            ...flatten(obj[i])\n                .map(v => [`or${i || ''}-${v[0]}`, v[1]]) as [string, string][]\n        );\n    }\n\n    return Object.fromEntries(entries);\n};\n\nconst flattenSelect = (obj: Select<any, any> = {}): string[] => {\n    const entries: string[] = [];\n\n    for (const [prop, value] of Object.entries(obj)) {\n        if (typeof value === 'object' && value) {\n            entries.push(...flattenSelect(value).map(v => `${prop}.${v}`));\n        } else if (value) {\n            entries.push(prop);\n        }\n    }\n\n    return entries;\n};\n\nexport const flattenSort = (obj: Sort<any>[] = []): {sort?: string} => {\n    const flatten = (obj: Sort<any>, base = ''): string | undefined => {\n        const [key, value] = Object.entries(obj ?? {})[0] ?? [];\n\n        if (key && value) {\n            const path = base + key;\n\n            if (typeof value === 'object') {\n                return flatten(value, path ? `${path}.` : '');\n            } else if (['asc', 'desc'].includes(value)) {\n                return `${value === 'desc' ? '-' : ''}${path}`;\n            }\n        }\n\n        return undefined;\n    };\n\n    const sorts = obj.map(v => flatten(v)).filter(Boolean);\n    return sorts.length ? {sort: sorts.join(',')} : {};\n};\n";
+
+const resolveImports = (target) => {
+    const imports = [];
+    if (isRXTarget(target)) {
+        imports.push(generateImport({ src: 'rxjs', imports: ['defer', 'Observable'] }));
+    }
+    return imports.join('\n');
+};
+const resolveMappings = (target) => `const wrapResponse = ${isRXTarget(target) ? 'defer' : '(v: (...args: any[]) => any) => v()'};`;
+const resolveBinaryClass = (target) => `const resolveBinaryObject = () => ${resolveBinaryType(target)};`;
+const generateBase = (target) => {
+    return generateStatements(resolveImports(target), resolveMappings(target), resolveBinaryClass(target), types$1, root);
+};
+
+const transformKey = (s) => snakeCase(s).toUpperCase();
+const generateEnum = (name, values) => {
+    const props = indent(values.map(v => `${transformKey(v)} = ${generateString(v)}`).join(',\n'));
+    return `export enum ${name} {\n${props}\n}`;
+};
+
+// We can't use the pascalCase utility as it converts "cDBReminderType" to "CDbReminderType" which is incorrect.
+const loosePascalCase = (str) => str[0].toUpperCase() + str.slice(1);
+
+const isObject = (v) => {
+    return v !== null && typeof v === 'object' && !Array.isArray(v);
+};
+const isParameterObject = (v) => {
+    return isObject(v) && typeof v.name === 'string' && typeof v.in === 'string';
+};
+const isReferenceObject = (v) => {
+    return isObject(v) && typeof v.$ref === 'string';
+};
+const isObjectSchemaObject = (v) => {
+    return isObject(v) && v.type === 'object' && isObject(v.properties);
+};
+const isEnumSchemaObject = (v) => {
+    return isObject(v) && v.type === 'string' && Array.isArray(v.enum);
+};
+const isArraySchemaObject = (v) => {
+    return isObject(v) && v.type === 'array' && typeof v.items === 'object';
+};
+const isResponseObject = (v) => {
+    return isObject(v) && typeof v.description === 'string';
+};
+const isNonArraySchemaObject = (v) => {
+    return isObject(v) && ['string', 'undefined'].includes(typeof v.type);
+};
+const isRelatedEntitySchema = (v) => {
+    return isObject(v) && isNonArraySchemaObject(v) && 'x-weclapp' in v && isObject(v['x-weclapp']);
+};
+
+const generateEnums = (schemas) => {
+    const enums = new Map();
+    for (const [propName, schema] of schemas) {
+        if (isEnumSchemaObject(schema)) {
+            const name = loosePascalCase(propName);
+            if (!enums.has(name)) {
+                enums.set(name, {
+                    properties: schema.enum,
+                    source: generateEnum(name, schema.enum)
+                });
+            }
+        }
+    }
+    return enums;
+};
+
+const concat = (strings, separator = ', ', maxLength = 80) => {
+    const joined = strings.join(separator);
+    if (joined.length > maxLength) {
+        const length = strings.length - 1;
+        return `\n${indent(strings
+            .map((value, index) => index === length ? value : `${(value + separator).trim()}\n`)
+            .join(''))}\n`;
+    }
+    else {
+        return joined;
+    }
+};
+
+/* eslint-disable no-use-before-define */
+const createReferenceType = (value) => ({
+    type: 'reference',
+    toString: () => loosePascalCase(value)
+});
+const createRawType = (value) => ({
+    type: 'raw',
+    toString: () => value
+});
+const createArrayType = (value) => ({
+    type: 'array',
+    toString: () => `${value.toString()}[]`
+});
+const createTupleType = (value) => ({
+    type: 'tuple',
+    toString: () => concat([...new Set(value.map(v => typeof v === 'string' ? `'${v}'` : v.toString()))], ' | ')
+});
+const createObjectType = (value, required = []) => ({
+    type: 'object',
+    isFullyOptional: () => {
+        return !required.length && Object.values(value)
+            .filter(v => v?.type === 'object')
+            .every(v => v.isFullyOptional());
+    },
+    toString: (propagateOptionalProperties = false) => {
+        const properties = Object.entries(value)
+            .filter(v => v[1])
+            .map(v => {
+            const name = v[0];
+            const value = v[1];
+            const isRequired = required.includes(name) || (value.type === 'object' && !value.isFullyOptional() && propagateOptionalProperties);
+            return `${name + (isRequired ? '' : '?')}: ${value.toString()};`;
+        });
+        return properties.length ? `{\n${indent(properties.join('\n'))}\n}` : '{}';
+    }
+});
+const getRefName = (obj) => {
+    return obj.$ref.replace(/.*\//, '');
+};
+const convertToTypeScriptType = (schema, property) => {
+    if (isReferenceObject(schema)) {
+        return createReferenceType(getRefName(schema));
+    }
+    else {
+        switch (schema.type) {
+            case 'integer':
+            case 'number':
+                return createRawType('number');
+            case 'string':
+                if (schema.enum) {
+                    return property ? createReferenceType(property) : createTupleType(schema.enum);
+                }
+                else {
+                    return schema.format === 'binary' ? createRawType('binary') : createRawType('string');
+                }
+            case 'boolean':
+                return createRawType('boolean');
+            case 'object': {
+                const { properties = {}, required = [] } = schema;
+                return createObjectType(Object.fromEntries(Object.entries(properties)
+                    .map(v => [v[0], convertToTypeScriptType(v[1])])), required);
+            }
+            case 'array':
+                return createArrayType(convertToTypeScriptType(schema.items, property));
+            default:
+                return createRawType('unknown');
+        }
+    }
+};
+
+const setEntityEnumProperty = (enums, prop, meta) => {
+    const referenceName = getRefName(prop);
+    const enumName = loosePascalCase(referenceName);
+    if (enums.has(enumName)) {
+        meta.enum = enumName;
+    }
+    else {
+        meta.entity = referenceName;
+    }
+};
+const extractPropertyMetaData = (enums, meta, prop) => {
+    const result = { service: meta.service, entity: meta.entity };
+    if (isReferenceObject(prop)) {
+        setEntityEnumProperty(enums, prop, result);
+        result.type = 'reference';
+        return result;
+    }
+    result.format = prop.format;
+    result.type = prop.type;
+    if (isArraySchemaObject(prop)) {
+        if (isReferenceObject(prop.items)) {
+            setEntityEnumProperty(enums, prop.items, result);
+            result.format = 'reference';
+        }
+        else {
+            result.format = 'string';
+        }
+    }
+    return result;
+};
+
+const generateInlineComment = (comment) => `/** ${comment} */`;
+const generateBlockComment = (comment, body) => `/**\n${comment.trim().replace(/^ */gm, ' * ')}\n */${body ? `\n${body}` : ''}`;
+
+const generateType = (name, value) => {
+    return `export type ${name} = ${value.trim()};`;
+};
+
+const arrayify = (v) => Array.isArray(v) ? v : [v];
+
+const generateInterfaceProperties = (entries) => {
+    const properties = entries
+        .filter(v => v.type !== undefined)
+        .filter((value, index, array) => array.findIndex(v => v.name === value.name) === index)
+        .map(({ name, type, required, readonly, comment }) => {
+        const cmd = comment ? `${generateInlineComment(comment)}\n` : '';
+        const req = required ? '' : '?';
+        const rol = readonly ? 'readonly ' : '';
+        return `${cmd + rol + name + req}: ${type};`;
+    })
+        .join('\n');
+    return properties.length ? `{\n${indent(properties)}\n}` : `{}`;
+};
+const generateInterfaceFromObject = (name, obj, propagateOptionalProperties) => `export interface ${name} ${obj.toString(propagateOptionalProperties)}`;
+const generateInterface = (name, entries, extend) => {
+    const signature = `${name} ${extend ? `extends ${arrayify(extend).join(', ')}` : ''}`.trim();
+    const body = generateInterfaceProperties(entries);
+    return `export interface ${signature} ${body}`;
+};
+const generateInterfaceType = (name, entries, extend) => {
+    const body = generateInterfaceProperties(entries);
+    const bases = extend ? arrayify(extend).join(' & ') : undefined;
+    return generateType(name, `${bases ? `${bases} & ` : ''}${body}`);
+};
+
+const generateEntities = (schemas, enums) => {
+    const entities = new Map();
+    for (const [schemaName, schema] of schemas) {
+        // Enums are generated separately
+        if (isEnumSchemaObject(schema)) {
+            continue;
+        }
+        const entity = pascalCase(schemaName);
+        // Entity and filter
+        const entityInterface = [];
+        const filterInterface = [];
+        // Referenced entities and property-to-referenced-entity mapping
+        const referenceInterface = [];
+        const referenceMappingsInterface = [];
+        const properties = new Map();
+        // The parent entity
+        let extend = undefined;
+        const processProperties = (props = {}) => {
+            for (const [name, property] of Object.entries(props)) {
+                const meta = isRelatedEntitySchema(property) ? property['x-weclapp'] : {};
+                if (meta.entity) {
+                    const type = `${pascalCase(meta.entity)}[]`;
+                    referenceInterface.push({ name, type, required: true });
+                    filterInterface.push({ name: meta.entity, type, required: true });
+                }
+                if (meta.service) {
+                    referenceMappingsInterface.push({ name, type: generateString(meta.service), required: true });
+                }
+                const type = convertToTypeScriptType(property, name).toString();
+                const comment = isNonArraySchemaObject(property) ?
+                    property.deprecated ? '@deprecated will be removed.' :
+                        property.format ? `format: ${property.format}` :
+                            undefined : undefined;
+                entityInterface.push({
+                    name, type, comment,
+                    required: meta.required,
+                    readonly: !isReferenceObject(property) && property.readOnly
+                });
+                properties.set(name, extractPropertyMetaData(enums, meta, property));
+            }
+        };
+        if (schema.allOf?.length) {
+            for (const item of schema.allOf) {
+                if (isReferenceObject(item)) {
+                    extend = convertToTypeScriptType(item).toString();
+                }
+                else if (isObjectSchemaObject(item)) {
+                    processProperties(item.properties);
+                }
+            }
+        }
+        processProperties(schema.properties);
+        const source = generateStatements(generateInterface(entity, entityInterface, extend), generateInterface(`${entity}_References`, referenceInterface, extend ? [`${extend}_References`] : undefined), generateInterface(`${entity}_Mappings`, referenceMappingsInterface, extend ? [`${extend}_Mappings`] : undefined), generateInterfaceType(`${entity}_Filter`, filterInterface, extend ? [entity, `${extend}_Filter`] : undefined));
+        entities.set(schemaName, {
+            extends: extend ? camelCase(extend) : extend,
+            properties,
+            source
+        });
+    }
+    return entities;
+};
+
+/**
+ * Pluralizes a word, most of the time correct.
+ * @param s String to pluralize.
+ */
+const pluralize = (s) => {
+    return s.endsWith('s') ? s :
+        s.endsWith('y') ? `${s.slice(0, -1)}ies` :
+            `${s}s`;
+};
+
+/* eslint-disable no-console */
+const logger = new class {
+    active = true;
+    warnings = 0;
+    errors = 0;
+    write(str = '') {
+        process.stdout.write(str);
+    }
+    blankLn(str = '') {
+        this.blank(`${str}\n`);
+    }
+    warnLn(str) {
+        this.warn(`${str}\n`);
+    }
+    errorLn(str) {
+        this.error(`${str}\n`);
+    }
+    successLn(str) {
+        this.success(`${str}\n`);
+    }
+    infoLn(str) {
+        this.info(`${str}\n`);
+    }
+    debugLn(str) {
+        this.debug(`${str}\n`);
+    }
+    blank(str) {
+        this.write(str);
+    }
+    warn(str) {
+        this.write(`${chalk.yellowBright('[!]')} ${str}`);
+        this.warnings++;
+    }
+    error(str) {
+        this.write(`${chalk.redBright('[X]')} ${str}`);
+        this.errors++;
+    }
+    success(str) {
+        this.write(`${chalk.greenBright('[✓]')} ${str}`);
+    }
+    info(str) {
+        this.write(`${chalk.blueBright('[i]')} ${str}`);
+    }
+    debug(str) {
+        this.write(`[-] ${str}`);
+    }
+    printSummary() {
+        const format = (v, name, fail, ok) => {
+            const color = v ? fail : ok;
+            return v === 0 ? `${color('zero')} ${pluralize(name)}` :
+                v === 1 ? `${color('one')} ${name}` : `${color(v)} ${pluralize(name)}`;
+        };
+        const warnings = format(this.warnings, 'warning', chalk.yellowBright, chalk.greenBright);
+        const errors = format(this.errors, 'error', chalk.redBright, chalk.greenBright);
+        const info = `Finished with ${warnings} and ${errors}.`;
+        this[this.errors ? 'errorLn' : this.warnings ? 'warnLn' : 'successLn'](info);
+    }
+};
+
+/**
+ * ROOT           => /article
+ * COUNT          => /article/count
+ * ENTITY         => /article/{id}
+ * SPECIAL_ROOT   => /article/generateImage
+ * SPECIAL_ENTITY => /article/id/{id}/generateImag
+ */
+var WeclappEndpointType;
+(function (WeclappEndpointType) {
+    WeclappEndpointType["ROOT"] = "ROOT";
+    WeclappEndpointType["COUNT"] = "COUNT";
+    WeclappEndpointType["ENTITY"] = "ENTITY";
+    WeclappEndpointType["GENERIC_ROOT"] = "GENERIC_ROOT";
+    WeclappEndpointType["GENERIC_ENTITY"] = "GENERIC_ENTITY";
+})(WeclappEndpointType || (WeclappEndpointType = {}));
+const parseEndpointPath = (path) => {
+    const [, entity, ...rest] = path.split('/');
+    if (!entity) {
+        return undefined;
+    }
+    if (!rest.length) {
+        return { path, entity, type: WeclappEndpointType.ROOT };
+    }
+    else if (rest[0] === 'count') {
+        return { path, entity, type: WeclappEndpointType.COUNT };
+    }
+    else if (rest[0] === 'id') {
+        return rest.length === 2 ?
+            { path, entity, type: WeclappEndpointType.ENTITY } :
+            { path, entity, method: rest[2], type: WeclappEndpointType.GENERIC_ENTITY };
+    }
+    else if (rest.length === 1) {
+        return { path, entity, method: rest[1], type: WeclappEndpointType.GENERIC_ROOT };
+    }
+    return undefined;
+};
+
+const generateArrowFunction = ({ name, signature, returns, params }) => {
+    return `const ${name}: ${signature} = (${params?.join(', ') ?? ''}) =>\n${indent(returns)};`;
+};
+
+const generateArrowFunctionType = ({ type, returns = 'void', generics, params }) => {
+    const genericsString = generics?.length ? `<\n${indent(generics.join(',\n'))}\n>` : '';
+    const paramsString = params?.length ? `(${params.join(', ')})` : `()`;
+    return generateType(type, `${genericsString + paramsString} =>\n${indent(returns)}`);
+};
+
+const convertParametersToSchema = (parameters = []) => {
+    const properties = [];
+    const required = [];
+    for (const param of parameters) {
+        if (isParameterObject(param) && param.in === 'query') {
+            if (param.schema) {
+                properties.push([param.name, param.schema]);
+                param.required && required.push(param.name);
+            }
+        }
+    }
+    return {
+        type: 'object', required,
+        properties: Object.fromEntries(properties)
+    };
+};
+
+const functionName$5 = 'count';
+const generateCountEndpoint = ({ aliases, path, target, endpoint }) => {
+    const service = pascalCase(endpoint.entity);
+    const entity = aliases.get(endpoint.entity) ?? service;
+    const entityFilter = `${entity}_Filter`;
+    const interfaceName = `${service}Service_${pascalCase(functionName$5)}`;
+    const entityParameters = `${interfaceName}_Parameters`;
+    const parameterSchema = convertParametersToSchema(path.parameters);
+    const parameters = createObjectType({
+        params: convertToTypeScriptType(parameterSchema)
+    });
+    const functionSource = generateArrowFunction({
+        name: functionName$5,
+        signature: interfaceName,
+        returns: `_${functionName$5}(cfg, ${generateString(endpoint.path)}, query)`,
+        params: ['query']
+    });
+    const interfaceSource = generateArrowFunctionType({
+        type: interfaceName,
+        params: [`query${parameters.isFullyOptional() ? '?' : ''}: CountQuery<${entityFilter}> & ${entityParameters}`],
+        returns: `${resolveResponseType(target)}<number>`
+    });
+    return {
+        entity,
+        name: functionName$5,
+        type: { name: interfaceName, source: interfaceSource },
+        func: { name: functionName$5, source: functionSource },
+        interfaces: [
+            {
+                name: entityParameters,
+                source: generateInterfaceFromObject(entityParameters, parameters, true)
+            }
+        ]
+    };
+};
+
+const generateBodyType = (body) => {
+    if (isReferenceObject(body)) {
+        return convertToTypeScriptType(body);
+    }
+    const types = [];
+    for (const { schema } of Object.values(body?.content ?? {})) {
+        if (schema) {
+            types.push(convertToTypeScriptType(schema));
+        }
+    }
+    return types.length ? createTupleType(types) : undefined;
+};
+
+const generateRequestBodyType = ({ requestBody }) => {
+    return generateBodyType(requestBody) ?? createRawType('unknown');
+};
+
+const generateResponseBodyType = ({ responses }) => {
+    return generateBodyType(Object.entries(responses)
+        .filter(v => v[0].startsWith('2'))[0]?.[1]) ?? createRawType('void');
+};
+
+const functionName$4 = 'create';
+const generateCreateEndpoint = ({ target, path, endpoint }) => {
+    const entity = pascalCase(endpoint.entity);
+    const interfaceName = `${entity}Service_${pascalCase(functionName$4)}`;
+    const functionSource = generateArrowFunction({
+        name: functionName$4,
+        signature: interfaceName,
+        returns: `_${functionName$4}(cfg, ${generateString(endpoint.path)}, data)`,
+        params: ['data']
+    });
+    const interfaceSource = generateArrowFunctionType({
+        type: interfaceName,
+        params: [`data: DeepPartial<${generateRequestBodyType(path).toString()}>`],
+        returns: `${resolveResponseType(target)}<${generateResponseBodyType(path).toString()}>`
+    });
+    return {
+        entity,
+        name: functionName$4,
+        type: { name: interfaceName, source: interfaceSource },
+        func: { name: functionName$4, source: functionSource }
+    };
+};
+
+const generateGenericFunctionName = (path, suffix = '', prefix = '') => {
+    return camelCase(`${prefix}_` +
+        path
+            .replace(/.*\//, '')
+            .replace(/\W+/, '_')
+            .replace(/[_]+/, '_') + `_${suffix}`);
+};
+
+const insertPathPlaceholder = (path, record) => {
+    return path.replace(/{(\w+)}/g, (_, name) => record[name]);
+};
+
+const wrapBody = (type, target) => {
+    return type.toString() === 'binary' ?
+        createRawType(isNodeTarget(target) ? 'BodyInit' : 'Blob') :
+        type; // node-fetch returns a Blob as well
+};
+const generateGenericEndpoint = (suffix) => ({ target, method, path, endpoint }) => {
+    const functionName = generateGenericFunctionName(endpoint.path, suffix, method);
+    const entity = pascalCase(endpoint.entity);
+    const interfaceName = `${entity}Service_${pascalCase(functionName)}`;
+    const entityQuery = `${interfaceName}_Query`;
+    const hasId = endpoint.path.includes('{id}');
+    const params = createObjectType({
+        params: convertToTypeScriptType(convertParametersToSchema(path.parameters)),
+        body: method === 'get' ? undefined : wrapBody(generateRequestBodyType(path), target)
+    });
+    const responseBody = generateResponseBodyType(path);
+    const forceBlobResponse = String(responseBody.toString() === 'binary');
+    const functionSource = generateArrowFunction({
+        name: functionName,
+        signature: interfaceName,
+        params: hasId ? ['id', 'query'] : ['query'],
+        returns: `_generic(cfg, ${generateString(method.toUpperCase())}, \`${insertPathPlaceholder(endpoint.path, { id: '${id}' })}\`, query, ${forceBlobResponse})`
+    });
+    const interfaceSource = generateArrowFunctionType({
+        type: interfaceName,
+        params: [...(hasId ? ['id: string'] : []), `query${params.isFullyOptional() ? '?' : ''}: ${entityQuery}`],
+        returns: `${resolveResponseType(target)}<${wrapBody(responseBody, target).toString()}>`
+    });
+    return {
+        entity,
+        name: functionName,
+        type: { name: interfaceName, source: interfaceSource },
+        func: { name: functionName, source: functionSource },
+        interfaces: [
+            {
+                name: entityQuery,
+                source: generateInterfaceFromObject(entityQuery, params, true)
+            }
+        ]
+    };
+};
+
+const functionName$3 = 'remove';
+const generateRemoveEndpoint = ({ target, endpoint }) => {
+    const entity = pascalCase(endpoint.entity);
+    const interfaceName = `${entity}Service_${pascalCase(functionName$3)}`;
+    const functionSource = generateArrowFunction({
+        name: functionName$3,
+        signature: interfaceName,
+        returns: `_${functionName$3}(cfg, \`${insertPathPlaceholder(endpoint.path, { id: '${id}' })}\`)`,
+        params: ['id']
+    });
+    const interfaceSource = generateArrowFunctionType({
+        type: interfaceName,
+        params: ['id: string'],
+        returns: `${resolveResponseType(target)}<void>`
+    });
+    return {
+        entity,
+        name: functionName$3,
+        type: { name: interfaceName, source: interfaceSource },
+        func: { name: functionName$3, source: functionSource }
+    };
+};
+
+const functionName$2 = 'some';
+const excludedParameters = [
+    'page', 'pageSize', 'sort',
+    'serializeNulls', 'properties', 'includeReferencedEntities'
+];
+const generateSomeEndpoint = ({ aliases, target, path, endpoint }) => {
+    // Required interface names
+    const service = pascalCase(endpoint.entity);
+    const entity = aliases.get(endpoint.entity) ?? service;
+    const interfaceName = `${service}Service_${pascalCase(functionName$2)}`;
+    const entityFilter = `${entity}_Filter`;
+    const entityMappings = `${entity}_Mappings`;
+    const entityReferences = `${entity}_References`;
+    const entityParameters = `${service}_Parameters`;
+    const parameterSchema = convertParametersToSchema(path.parameters);
+    // We already cover page, pageSize and sort
+    parameterSchema.properties = Object.fromEntries(Object.entries(parameterSchema.properties ?? {})
+        .filter(v => !excludedParameters.includes(v[0])));
+    const parameters = createObjectType({
+        params: convertToTypeScriptType(parameterSchema)
+    });
+    const interfaceSource = generateArrowFunctionType({
+        type: interfaceName,
+        generics: [
+            `S extends (QuerySelect<${entity}> | undefined) = undefined`,
+            `I extends (QuerySelect<${entityMappings}> | undefined) = undefined`
+        ],
+        params: [`query${parameters.isFullyOptional() ? '?' : ''}: SomeQuery<${entity}, ${entityFilter}, I, S> & ${entityParameters}`],
+        returns: `${resolveResponseType(target)}<SomeQueryReturn<${entity}, ${entityReferences}, ${entityMappings}, I, S>>`
+    });
+    const functionSource = generateArrowFunction({
+        name: functionName$2,
+        signature: interfaceName,
+        returns: `_${functionName$2}(cfg, ${generateString(endpoint.path)}, query)`,
+        params: ['query']
+    });
+    return {
+        entity,
+        name: functionName$2,
+        type: { name: interfaceName, source: interfaceSource },
+        func: { name: functionName$2, source: functionSource },
+        interfaces: [
+            {
+                name: entityParameters,
+                source: generateInterfaceFromObject(entityParameters, parameters, true)
+            }
+        ]
+    };
+};
+
+const functionName$1 = 'unique';
+const generateUniqueEndpoint = ({ target, path, endpoint }) => {
+    const entity = pascalCase(endpoint.entity);
+    const interfaceName = `${entity}Service_${pascalCase(functionName$1)}`;
+    const functionSource = generateArrowFunction({
+        name: functionName$1,
+        signature: interfaceName,
+        params: ['id', 'query'],
+        returns: `_${functionName$1}(cfg, \`${insertPathPlaceholder(endpoint.path, { id: '${id}' })}\`, query)`
+    });
+    const interfaceSource = generateArrowFunctionType({
+        type: interfaceName,
+        params: ['id: string', 'query?: Q'],
+        generics: ['Q extends UniqueQuery'],
+        returns: `${resolveResponseType(target)}<${generateResponseBodyType(path).toString()}>`
+    });
+    return {
+        entity,
+        name: functionName$1,
+        type: { name: interfaceName, source: interfaceSource },
+        func: { name: functionName$1, source: functionSource }
+    };
+};
+
+const functionName = 'update';
+const generateUpdateEndpoint = ({ target, path, endpoint }) => {
+    const entity = pascalCase(endpoint.entity);
+    const interfaceName = `${entity}Service_${pascalCase(functionName)}`;
+    const interfaceSource = generateArrowFunctionType({
+        type: interfaceName,
+        params: ['id: string', `data: DeepPartial<${generateRequestBodyType(path).toString()}>`, 'options?: UpdateQuery'],
+        returns: `${resolveResponseType(target)}<${generateResponseBodyType(path).toString()}>`
+    });
+    const functionSource = generateArrowFunction({
+        name: functionName,
+        signature: interfaceName,
+        returns: `_${functionName}(cfg, \`${insertPathPlaceholder(endpoint.path, { id: '${id}' })}\`, data, options)`,
+        params: ['id', 'data', 'options']
+    });
+    return {
+        entity,
+        name: functionName,
+        type: { name: interfaceName, source: interfaceSource },
+        func: { name: functionName, source: functionSource }
+    };
+};
+
+const groupEndpointsByEntity = (paths) => {
+    const endpoints = new Map();
+    for (const [rawPath, path] of Object.entries(paths)) {
+        const endpoint = parseEndpointPath(rawPath);
+        if (!endpoint || !path) {
+            logger.errorLn(`Failed to parse ${rawPath}`);
+            continue;
+        }
+        if (endpoints.has(endpoint.entity)) {
+            endpoints.get(endpoint.entity)?.push({ endpoint, path });
+        }
+        else {
+            endpoints.set(endpoint.entity, [{ endpoint, path }]);
+        }
+    }
+    return endpoints;
+};
+
+const generators = {
+    /* /article */
+    [WeclappEndpointType.ROOT]: {
+        get: generateSomeEndpoint,
+        post: generateCreateEndpoint
+    },
+    /* /article/count */
+    [WeclappEndpointType.COUNT]: {
+        get: generateCountEndpoint
+    },
+    /* /article/:id */
+    [WeclappEndpointType.ENTITY]: {
+        get: generateUniqueEndpoint,
+        delete: generateRemoveEndpoint,
+        put: generateUpdateEndpoint
+    },
+    /* /article/:id/method */
+    [WeclappEndpointType.GENERIC_ENTITY]: {
+        get: generateGenericEndpoint('ById'),
+        post: generateGenericEndpoint('ById')
+    },
+    /* /article/method */
+    [WeclappEndpointType.GENERIC_ROOT]: {
+        get: generateGenericEndpoint(),
+        post: generateGenericEndpoint()
+    }
+};
+const generateServices = (doc, aliases, options) => {
+    const services = new Map();
+    const grouped = groupEndpointsByEntity(doc.paths);
+    for (const [endpoint, paths] of grouped) {
+        const serviceName = camelCase(`${endpoint}Service`);
+        const serviceTypeName = pascalCase(`${endpoint}Service`);
+        // Service functions
+        const functions = [];
+        for (const { path, endpoint } of paths) {
+            const resolver = generators[endpoint.type];
+            for (const [method, config] of Object.entries(path)) {
+                if (method === 'get' && endpoint.type === WeclappEndpointType.ENTITY && !options.generateUnique) {
+                    continue;
+                }
+                if (resolver[method]) {
+                    const path = config;
+                    const target = options.target;
+                    if (!path.deprecated || options.deprecated) {
+                        functions.push({
+                            ...resolver[method]({ endpoint, method, target, path, aliases }),
+                            path
+                        });
+                    }
+                }
+                else {
+                    logger.errorLn(`Failed to generate a function for ${method.toUpperCase()}:${endpoint.type} ${endpoint.path}`);
+                }
+            }
+        }
+        if (!functions.length) {
+            continue;
+        }
+        // Construct service type
+        const types = generateStatements(...functions.flatMap(v => v.interfaces?.map(v => v.source) ?? []), ...functions.map(v => v.type.source), generateInterface(serviceTypeName, [
+            ...functions.map(v => ({
+                required: true,
+                comment: v.path.deprecated ? '@deprecated' : undefined,
+                name: v.func.name,
+                type: v.type.name
+            }))
+        ]));
+        // Construct service value
+        const funcBody = generateBlockStatements(...functions.map(v => v.func.source), `return {${concat(functions.map(v => v.func.name))}};`);
+        const func = `export const ${serviceName} = (cfg?: ServiceConfig): ${serviceTypeName} => ${funcBody};`;
+        const source = generateBlockComment(`${pascalCase(endpoint)} service`, generateStatements(types, func));
+        const deprecated = functions.every(v => v.path.deprecated);
+        services.set(endpoint, { entity: endpoint, deprecated, serviceName, serviceTypeName, source, functions });
+    }
+    return services;
+};
+
+const generateCustomValueUtilities = (entities, services) => {
+    const customValueEntity = entities.get('customValue');
+    const customValueEntities = [];
+    if (!customValueEntity) {
+        logger.warn('Cannot generate custom value utils, type not found.');
+        return '';
+    }
+    serviceLoop: for (const service of services) {
+        const someFunction = service.functions.find(v => v.name === 'some');
+        if (!someFunction) {
+            continue;
+        }
+        const entity = entities.get(camelCase(someFunction.entity));
+        if (entity?.properties.size !== customValueEntity.properties.size) {
+            continue;
+        }
+        for (const [prop, { type }] of entity.properties) {
+            if (customValueEntity.properties.get(prop)?.type !== type) {
+                continue serviceLoop;
+            }
+        }
+        customValueEntities.push(service.entity);
+    }
+    return generateBlockComment('Utilities to identify services that return an entity that is an alias to CustomValue.', generateStatements(generateType('WCustomValueService', concat(generateStrings(customValueEntities), ' | ')), `export const wCustomValueServiceNames: WCustomValueService[] = [${concat(generateStrings(customValueEntities))}];`, `export const isWCustomValueService = (service: string | undefined): service is WCustomValueService =>\n${indent('wCustomValueServiceNames.includes(service as WCustomValueService);')}`));
+};
+
+const generateObject = (properties) => {
+    const body = [];
+    for (const { key, value } of properties) {
+        if (value === undefined) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            const str = generateObject(value);
+            if (str.length > 2) {
+                body.push(`${key}: ${str}`);
+            }
+        }
+        else {
+            body.push(`${key}: ${String(value)}`);
+        }
+    }
+    return body.length ? `{\n${indent(body.join(',\n'))}\n}` : `{}`;
+};
+
+const resolveInheritedEntities = (root, entities) => {
+    const parent = root.extends ? entities.get(root.extends) : undefined;
+    return parent ? [parent, ...resolveInheritedEntities(parent, entities)] : [];
+};
+const generatePropertyDescriptors = (entity, entities, services, options) => [
+    ...resolveInheritedEntities(entity, entities).flatMap(v => [...v.properties]),
+    ...entity.properties
+].filter(([, meta]) => {
+    // If we generate deprecated things we can skip the filtering
+    if (options.deprecated) {
+        return true;
+    }
+    // Check if corresponding service is deprecated and can be removed
+    const service = services.find(v => v.entity === meta.service);
+    return !meta.service || (service && !service.deprecated);
+}).map(([property, meta]) => ({
+    key: property,
+    value: Object.entries(meta).map(([key, value]) => ({
+        key,
+        value: value ? generateString(value) : undefined
+    }))
+}));
+const generateEntityPropertyMap = (entities, services, options) => {
+    const typeName = 'WEntityProperties';
+    const propertyMap = [...entities].map(([entity, data]) => ({
+        key: entity,
+        value: generatePropertyDescriptors(data, entities, services, options)
+    }));
+    return generateStatements(`export type ${typeName} = Partial<Record<WEntity, Partial<Record<string, WEntityPropertyMeta>>>>;`, `export const wEntityProperties: ${typeName} = ${generateObject(propertyMap)};`);
+};
+
+const generateArray = (values) => {
+    return `[${concat(values.map(v => generateString(String(v))))}]`;
+};
+
+// Only functions matching this regex are included in the generation.
+const FILTER_REGEX = /^(some|count|create|remove|unique|update)$/;
+/**
+ * Generates for each function a map with the entity-name as key and service type as value.
+ * E.g. WServicesWith[Function] where [Function] may be something like "some" or "create".
+ *
+ * This function also generates an exported array with the names of each service for each name.
+ */
+const generateGroupedServices = (services) => {
+    const entityDescriptors = new Map();
+    for (const { entity, functions } of services) {
+        for (const { name } of functions) {
+            if (!FILTER_REGEX.test(name)) {
+                continue;
+            }
+            entityDescriptors.set(name, [
+                ...(entityDescriptors.get(name) ?? []), {
+                    name: entity,
+                    required: true,
+                    type: `${pascalCase(entity)}Service_${pascalCase(name)}`
+                }
+            ]);
+        }
+    }
+    const descriptors = [...entityDescriptors.entries()];
+    const typeGuards = [];
+    for (const [name] of descriptors) {
+        const constant = camelCase(`wServiceWith_${name}_Names`);
+        const service = pascalCase(`WServiceWith_${name}`);
+        const guard = `(service: string | undefined): service is ${service} =>\n${indent(`${constant}.includes(service as ${service});`)}`;
+        typeGuards.push(`export const is${service} = ${guard}`);
+    }
+    return [
+        ...descriptors.map(([name, props]) => generateInterface(pascalCase(`WServicesWith_${name}`), props)),
+        ...descriptors.map(([name]) => generateType(pascalCase(`WServiceWith_${name}`), `keyof ${pascalCase(`WServicesWith_${name}`)}`)),
+        ...descriptors.map(([name, props]) => {
+            const constant = camelCase(`wServiceWith_${name}_Names`);
+            const type = pascalCase(`WServiceWith_${name}`);
+            const value = generateArray(props.map(v => v.name));
+            return `export const ${constant}: ${type}[] = ${value};`;
+        }),
+        generateBlockComment('Type guards for service classes.', generateStatements(...typeGuards))
+    ];
+};
+
+const obj = (list) => `{\n${indent(list.join(',\n'))}\n}`;
+const arr = (list) => `[\n${indent(list.join(',\n'))}\n]`;
+const generateMaps = ({ services, entities, aliases, enums, options }) => {
+    const entitiesKeys = [...entities.keys()];
+    const enumsArray = `export const wEnums = ${obj(enums)};`;
+    const entityNames = `export const wEntityNames: WEntity[] = ${arr(entitiesKeys.map(v => `'${v}'`))};`;
+    const serviceNames = `export const wServiceNames: WService[] = ${arr(services.map(v => `'${v.entity}'`))};`;
+    const serviceValues = `export const wServiceFactories = ${obj(services.map(v => `${v.entity}: ${v.serviceName}`))};`;
+    const serviceInstanceValues = `export const wServices = ${obj(services.map(v => {
+        const src = `${v.entity}: ${v.serviceName}()`;
+        return v.deprecated ? generateInlineComment('@deprecated') + `\n${src}` : src;
+    }))};`;
+    const entityInterfaces = [
+        ...entitiesKeys.map(entity => ({
+            name: entity,
+            type: pascalCase(entity),
+            required: true
+        })),
+        ...services.map(service => {
+            const alias = aliases.get(service.entity);
+            return {
+                name: service.entity,
+                type: alias ?? 'never',
+                required: true,
+                comment: alias ? undefined : 'no response defined or inlined'
+            };
+        })
+    ];
+    const createMappingType = (type, prefix) => type !== 'never' ? `${type}_${prefix}` : type;
+    const entitiesList = generateInterface('WEntities', entityInterfaces);
+    const entityReferences = generateInterface('WEntityReferences', entityInterfaces.map(v => ({ ...v, type: createMappingType(v.type, 'References') })));
+    const entityMappings = generateInterface('WEntityMappings', entityInterfaces.map(v => ({ ...v, type: createMappingType(v.type, 'Mappings') })));
+    const entityFilter = generateInterface('WEntityFilters', entityInterfaces.map(v => ({ ...v, type: createMappingType(v.type, 'Filter') })));
+    return {
+        source: generateStatements(
+        /* JS Values */
+        serviceValues, serviceInstanceValues, entityNames, serviceNames, enumsArray, generateEntityPropertyMap(entities, services, options), 
+        /* Map of entity to references / mappings and filters*/
+        entityReferences, entityMappings, entityFilter, 
+        /* List of all entities with their corresponding service */
+        generateBlockComment(`
+                This interfaces merges two maps:
+                - Map<[entityName], [entityInterfaceName]>
+                - Map<[serviceName], [entityInterfaceName]>
+                
+                Where [entityName] is 
+                - the name of a nested entity (e.g. 'address' from Party)
+                - the name of an entity (e.g. 'party', 'article' etc.)
+                
+                Where [serviceName] is the name of an endpoint (e.g. for /article its 'article')
+               
+                Where [entityInterfaceName] is
+                - the underlying type for this entity
+                - the type for what is returned by the api
+            `, entitiesList), 
+        /* type-ofs and types */
+        generateType('WServices', 'typeof wServices'), generateType('WServiceFactories', 'typeof wServiceFactories'), generateType('WService', 'keyof WServices'), generateType('WEntity', 'keyof WEntities'), generateType('WEnums', 'typeof wEnums'), generateType('WEnum', 'keyof WEnums'), 
+        /* Utilities. */
+        generateCustomValueUtilities(entities, services), 
+        /* All functions grouped by service supporting it */
+        ...generateGroupedServices(services))
+    };
+};
+
+const parseReferencedEntity = (obj) => pascalCase(obj.$ref.replace(/.*\//, ''));
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+const extractSchemas = (doc) => {
+    const schemas = new Map();
+    const aliases = new Map();
+    for (const [name, schema] of Object.entries(doc.components?.schemas ?? {})) {
+        if (!isReferenceObject(schema)) {
+            schemas.set(name, schema);
+        }
+    }
+    /**
+     * Referenced schemas in responses, in some case the response from the root endpoint
+     * refers to a schema with a different name
+     */
+    for (const [path, methods] of Object.entries(doc.paths)) {
+        const parsed = parseEndpointPath(path);
+        if (!parsed || schemas.has(parsed.entity)) {
+            continue;
+        }
+        for (const method of Object.values(OpenAPIV3.HttpMethods)) {
+            const body = methods[method]?.responses['200'];
+            if (isResponseObject(body) && body.content) {
+                const responseSchema = Object.values(body.content)[0]?.schema;
+                if (isReferenceObject(responseSchema)) {
+                    continue;
+                }
+                const itemsSchema = responseSchema?.properties?.result;
+                if (isReferenceObject(itemsSchema)) {
+                    aliases.set(parsed.entity, parseReferencedEntity(itemsSchema));
+                    continue;
+                }
+                if (isArraySchemaObject(itemsSchema)) {
+                    const { items } = itemsSchema;
+                    if (isReferenceObject(items)) {
+                        aliases.set(parsed.entity, parseReferencedEntity(items));
+                    }
+                }
+            }
+        }
+    }
+    return { schemas, aliases };
+};
+
+const generate = (doc, options) => {
+    const { schemas, aliases } = extractSchemas(doc);
+    const enums = generateEnums(schemas);
+    const entities = generateEntities(schemas, enums);
+    const services = generateServices(doc, aliases, options);
+    return generateStatements(generateBase(options.target), generateBlockComment('ENUMS', generateStatements(...[...enums.values()].map(v => v.source))), generateBlockComment('ENTITIES', generateStatements(...[...entities.values()].map(v => v.source))), generateBlockComment('SERVICES', generateStatements(...[...services.values()].map(v => v.source))), generateBlockComment('MAPS', generateMaps({
+        services: [...services.values()],
+        enums: [...enums.keys()],
+        options,
+        entities,
+        aliases
+    }).source));
+};
+
+const hash = (content, algorithm = 'sha256') => {
+    const hash = createHash(algorithm);
+    if (Array.isArray(content)) {
+        content.map(hash.update.bind(hash));
+    }
+    else {
+        hash.update(content);
+    }
+    return hash.digest('hex');
+};
+
+var name = "@weclapp/sdk";
+var version = "^1.8.0";
+var description = "SDK generator based on a weclapp api swagger file";
+var author = "weclapp";
+var sideEffects = false;
+var bin = {
+	"build-weclapp-sdk": "./bin/cli.js"
+};
+var files = [
+	"bin",
+	"dist",
+	"tsconfig.lib.json"
+];
+var engines = {
+	node: "^18 || ^20",
+	npm: "^9 || ^8"
+};
+var types = "./sdk/dist/index.d.ts";
+var main = "./sdk/dist/index.cjs";
+var module = "./sdk/dist/index.js";
+var type = "module";
+var exports = {
+	".": {
+		types: "./sdk/dist/index.d.ts",
+		"import": "./sdk/dist/index.js",
+		require: "./sdk/dist/index.cjs"
+	}
+};
+var scripts = {
+	"cli:build": "cross-env NODE_ENV=production rollup -c rollup.config.js",
+	"cli:watch": "cross-env NODE_ENV=development rollup -c rollup.config.js --watch",
+	"sdk:build": "./bin/cli.js test/openapi.json --target node",
+	lint: "eslint {src,test}/**/*.ts",
+	"lint:fix": "npm run lint -- --fix",
+	"ci:test": "npm run lint:fix && npm run cli:build && npm run sdk:build",
+	release: "standard-version"
+};
+var repository = {
+	type: "git",
+	url: "git@git.internal.weclapp.com:weclapp/weclapp-api/sdk-generator.git"
+};
+var devDependencies = {
+	"@typescript-eslint/eslint-plugin": "^5.59.11",
+	"@typescript-eslint/parser": "^5.59.11",
+	eslint: "^8.42.0",
+	"rollup-plugin-string": "^3.0.0",
+	"standard-version": "^9.5.0"
+};
+var dependencies = {
+	"@rollup/plugin-json": "^6.0.0",
+	"@rollup/plugin-terser": "^0.4.3",
+	"@types/fs-extra": "^11.0.1",
+	"@types/yargs": "^17.0.24",
+	chalk: "^5.2.0",
+	"change-case": "^4.1.2",
+	"cross-env": "^7.0.3",
+	dotenv: "^16.1.4",
+	"indent-string": "^5.0.0",
+	"openapi-types": "^12.1.3",
+	"pretty-ms": "^8.0.0",
+	rollup: "^3.25.1",
+	"rollup-plugin-ts": "^3.2.0",
+	typescript: "^5.1.3",
+	yargs: "^17.7.2"
+};
+var peerDependencies = {
+	rxjs: "^7.5.5"
+};
+var pkg = {
+	name: name,
+	version: version,
+	description: description,
+	author: author,
+	sideEffects: sideEffects,
+	bin: bin,
+	files: files,
+	engines: engines,
+	types: types,
+	main: main,
+	module: module,
+	type: type,
+	exports: exports,
+	scripts: scripts,
+	repository: repository,
+	devDependencies: devDependencies,
+	dependencies: dependencies,
+	peerDependencies: peerDependencies
+};
+
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+const cli = async () => {
+    const { argv } = yargs(hideBin(process.argv))
+        .scriptName('build-weclapp-sdk')
+        .usage('Usage: $0 <source> [flags]')
+        .version(version)
+        .example('$0 openapi.json', 'Generate the SDK based on a local openapi file')
+        .example('$0 xxx.weclapp.com --key ...', 'Generate the SDK based on the openapi file from the given weclapp instance')
+        .help('h')
+        .alias('v', 'version')
+        .alias('h', 'help')
+        .option('k', {
+        alias: 'key',
+        describe: 'API Key (only needed when not using a local file)',
+        type: 'string'
+    })
+        .option('c', {
+        alias: 'cache',
+        describe: 'If the generated SDK should cached',
+        type: 'boolean'
+    })
+        .option('q', {
+        alias: 'query',
+        describe: 'Extra query params when fetching the openapi.json from a server',
+        type: 'string'
+    })
+        .option('generate-unique', {
+        describe: 'Generate .unique functions',
+        type: 'boolean'
+    })
+        .option('d', {
+        alias: 'deprecated',
+        describe: 'Include deprecated functions and services',
+        type: 'boolean'
+    })
+        .option('e', {
+        alias: 'from-env',
+        describe: 'Use env variables WECLAPP_BACKEND_URL and WECLAPP_API_KEY as credentials',
+        type: 'boolean'
+    })
+        .option('t', {
+        alias: 'target',
+        describe: 'Specify the target platform',
+        type: 'string',
+        choices: ['browser', 'browser.rx', 'node', 'node.rx']
+    })
+        .option('d', {
+        alias: 'deprecated',
+        describe: 'Include deprecated functions and services',
+        type: 'boolean'
+    })
+        .epilog(`Copyright ${new Date().getFullYear()} weclapp GmbH`);
+    if (argv.fromEnv) {
+        config();
+    }
+    const { WECLAPP_API_KEY, WECLAPP_BACKEND_URL } = process.env;
+    const { query, cache = false, deprecated = false, key = WECLAPP_API_KEY, _: [src = WECLAPP_BACKEND_URL] } = argv;
+    const options = {
+        deprecated,
+        generateUnique: argv.generateUnique ?? false,
+        target: argv.target ?? Target.BROWSER_PROMISES
+    };
+    if (typeof src === 'number') {
+        return Promise.reject('Expected string as command');
+    }
+    if (!Object.values(Target).includes(options.target)) {
+        logger.errorLn(`Unknown target: ${options.target}. Possible values are ${Object.values(Target).join(', ')}`);
+        return Promise.reject();
+    }
+    if (await stat(src).catch(() => false)) {
+        logger.infoLn(`Source is a file`);
+        const content = JSON.parse(await readFile(src, 'utf-8'));
+        return { cache, content, options };
+    }
+    const url = new URL(src.startsWith('http') ? src : `https://${src}`);
+    url.pathname = '/webapp/api/v1/meta/openapi.json';
+    if (query?.length) {
+        for (const param of query.split(',')) {
+            const [name, value] = param.split('=');
+            url.searchParams.set(name, value);
+        }
+    }
+    const content = await fetch(url.toString(), {
+        headers: { 'Accept': 'application/json', 'AuthenticationToken': key }
+    }).then(res => res.ok ? res.json() : undefined);
+    if (!content) {
+        logger.errorLn(`Couldn't fetch file ${url.toString()} `);
+        return Promise.reject();
+    }
+    else {
+        logger.infoLn(`Use remote file: ${url.toString()}`);
+    }
+    return { cache, content, options };
+};
+
+const workingDirectory = resolve(currentDirname(), './sdk');
+const folders = ['docs', 'main', 'node', 'raw', 'rx', 'utils'];
+void (async () => {
+    const start = process.hrtime.bigint();
+    const { content: doc, cache: useCache, options } = await cli();
+    // Resolve cache dir and key
+    const cacheKey = hash([pkg.version, JSON.stringify(doc), JSON.stringify(options)]).slice(-8);
+    const cacheDir = resolve(currentDirname(), '.tmp', cacheKey);
+    const dist = (...paths) => resolve(workingDirectory, ...paths);
+    const tmp = async (...paths) => {
+        const fullPath = resolve(cacheDir, ...paths);
+        await mkdir(dirname(fullPath), { recursive: true }).catch(() => null);
+        return fullPath;
+    };
+    if (useCache) {
+        logger.infoLn(`Cache ID: ${cacheKey}`);
+    }
+    if (useCache && await stat(cacheDir).catch(() => false)) {
+        logger.successLn(`Cache match! (${cacheDir})`);
+    }
+    else {
+        // Store swagger.json file
+        await writeFile(await tmp('openapi.json'), JSON.stringify(doc, null, 2));
+        logger.infoLn(`Generate sdk (target: ${options.target})`);
+        // Generate SDKs
+        const sdk = generate(doc, options);
+        await writeFile(await tmp('src', `${options.target}.ts`), sdk.trim() + '\n');
+        // Bundle
+        logger.infoLn('Bundle... (this may take some time)');
+        await bundle(cacheDir, options.target);
+        // Remove old SDK
+        await Promise.all(folders.map(async (dir) => rm(dist(dir), { recursive: true }).catch(() => 0)));
+    }
+    // Copy bundled SDK
+    await cp(cacheDir, workingDirectory, { recursive: true });
+    // Print job summary
+    const duration = (process.hrtime.bigint() - start) / 1000000n;
+    logger.successLn(`SDK built in ${prettyMs(Number(duration))}`);
+    logger.printSummary();
+})().catch((error) => {
+    logger.errorLn(`Fatal error:`);
+    /* eslint-disable no-console */
+    console.error(error);
+}).finally(() => {
+    logger.errors && process.exit(1);
+});