@weclapp/sdk 2.0.0-dev.23 → 2.0.0-dev.25

package/dist/cli.js

@@ -1,17 +1,18 @@
 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 ts from '@rollup/plugin-typescript';
 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 { stat, readFile, rm, cp, writeFile, mkdir } from 'fs/promises';
 import { config } from 'dotenv';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
+import pkg from '../package.json' with { type: 'json' };
 import prettyMs from 'pretty-ms';
 
 var Target;
@@ -28,87 +29,74 @@ const isRXTarget = (target) => {
     return target === Target.BROWSER_RX || target === Target.NODE_RX;
 };
 const resolveResponseType = (target) => {
-    return isRXTarget(target) ? 'Observable' : 'Promise';
+    return isRXTarget(target) ? "Observable" : "Promise";
 };
 const resolveBinaryType = (target) => {
-    return isNodeTarget(target) ? 'Buffer' : 'Blob';
+    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));
+    return fileURLToPath(new URL("..", import.meta.url));
 };
 
-const tsconfig = resolve(currentDirname(), './tsconfig.lib.json');
-const resolveGlobals = (...globals) => Object.fromEntries(globals.map(v => [v, '*']));
+const tsconfig = resolve(currentDirname(), "./tsconfig.sdk.json");
+const resolveGlobals = (...globals) => Object.fromEntries(globals.map((v) => [v, "*"]));
 const generateOutput = (config) => ({
     sourcemap: true,
     banner: `/* weclapp sdk */`,
-    ...config
+    ...config,
 });
 const bundle = async (workingDirectory, target) => {
-    const dist = (...paths) => resolve(workingDirectory, 'dist', ...paths);
-    const src = (...paths) => resolve(workingDirectory, 'src', ...paths);
+    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')
+            file: dist("index.cjs"),
+            format: "cjs",
+            globals: resolveGlobals("node-fetch", "url"),
         }),
         generateOutput({
-            file: dist('index.js'),
-            format: 'es',
-            globals: resolveGlobals('node-fetch', 'url')
-        })
+            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'),
+            input: src("index.ts"),
+            plugins: [ts({ tsconfig, declarationDir: dist() }), terser()],
             output: [
                 generateOutput({
-                    file: dist('index.cjs'),
-                    name: 'Weclapp',
-                    format: 'umd'
+                    file: dist("index.js"),
+                    format: "es",
                 }),
-                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()],
+            input: src("index.ts"),
+            plugins: [ts({ tsconfig, declarationDir: dist() }), terser()],
+            external: ["rxjs"],
             output: [
                 generateOutput({
-                    file: dist('index.cjs'),
-                    name: 'Weclapp',
-                    format: 'umd',
-                    globals: resolveGlobals('rxjs')
+                    file: dist("index.js"),
+                    format: "es",
+                    globals: resolveGlobals("rxjs"),
                 }),
-                generateOutput({
-                    file: dist('index.js'),
-                    format: 'es',
-                    globals: resolveGlobals('rxjs')
-                })
-            ]
+            ],
         }),
         [Target.NODE_PROMISES]: () => ({
-            input: src('node.ts'),
+            input: src("index.ts"),
+            plugins: [ts({ tsconfig, declarationDir: dist() }), terser()],
+            external: ["node-fetch", "url"],
             output: generateNodeOutput(),
-            external: ['node-fetch', 'url'],
-            plugins: [ts({ tsconfig })]
         }),
         [Target.NODE_RX]: () => ({
-            input: src('node.rx.ts'),
+            input: src("index.ts"),
+            plugins: [ts({ tsconfig, declarationDir: dist() }), terser()],
+            external: ["node-fetch", "url", "rxjs"],
             output: generateNodeOutput(),
-            external: ['node-fetch', 'url', 'rxjs'],
-            plugins: [ts({ tsconfig })]
-        })
+        }),
     };
     const config = bundles[target]();
     const bundle = await rollup(config);
@@ -125,8 +113,11 @@ 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)};`;
+    const imports = [
+        opt.default,
+        opt.imports?.length ? `{${opt.imports.join(", ")}}` : "",
+    ];
+    return `import ${imports.filter(Boolean).join(", ")} from ${generateString(opt.src)};`;
 };
 
 /**
@@ -139,9 +130,9 @@ const indent = (s, level = 1) => {
 };
 
 const generateStatements = (...statements) => statements
-    .map(v => v.trim())
-    .filter(v => v.length)
-    .join('\n\n');
+    .map((v) => v.trim())
+    .filter((v) => v.length)
+    .join("\n\n");
 const generateBlockStatements = (...statements) => `{\n${indent(generateStatements(...statements))}\n}`;
 
 var globalConfig = "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 (browser env).\n    host?: string;\n\n    // If you want to use https, defaults to location.protocol (browser env).\n    secure?: boolean;\n\n    // If you want that some and count requests are bundled into multi requests.\n    multiRequest?: boolean;\n\n    // If you want that the ignoreMissingProperties parameter to be set to true for every post request.\n    ignoreMissingProperties?: 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\ntype ServiceConfigWithoutMultiRequest = Omit<ServiceConfig, 'multiRequest'>;\n\nlet globalConfig: ServiceConfig | undefined;\nexport const getGlobalConfig = (): ServiceConfig | undefined => globalConfig;\nexport const setGlobalConfig = (cfg?: ServiceConfig) => globalConfig = cfg;\n\nexport const getHost = (cfg: ServiceConfig) => {\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 host');\n    }\n\n    return host;\n};\n\nexport const getProtocol = (cfg: ServiceConfig) => {\n  const protocol =\n    cfg.secure !== undefined\n      ? cfg.secure\n        ? 'https:'\n        : 'http:'\n      : typeof location !== 'undefined'\n        ? location.protocol\n        : undefined;\n\n  if (!protocol) {\n    throw new Error('Please specify a protocol (secure)');\n  }\n\n  return protocol;\n};";
@@ -155,11 +146,11 @@ var types = "export type DeepPartial<T> = T extends object ? {\n    [P in keyof
 const resolveImports = (target) => {
     const imports = [];
     if (isRXTarget(target)) {
-        imports.push(generateImport({ src: 'rxjs', imports: ['defer', 'Observable'] }));
+        imports.push(generateImport({ src: "rxjs", imports: ["defer", "Observable"] }));
     }
-    return imports.join('\n');
+    return imports.join("\n");
 };
-const resolveMappings = (target) => `const wrapResponse = ${isRXTarget(target) ? 'defer' : '(v: (...args: any[]) => any) => v()'};`;
+const resolveMappings = (target) => `const wrapResponse = ${isRXTarget(target) ? "defer" : "(v: (...args: any[]) => any) => v()"};`;
 const resolveBinaryClass = (target) => `const resolveBinaryObject = () => ${resolveBinaryType(target)};`;
 const generateBase = (target, apiVersion) => {
     return generateStatements(resolveImports(target), resolveMappings(target), resolveBinaryClass(target), `const apiVersion = ${apiVersion}`, globalConfig, multiRequest, types, root);
@@ -167,7 +158,7 @@ const generateBase = (target, apiVersion) => {
 
 const transformKey = (s) => snakeCase(s).toUpperCase();
 const generateEnum = (name, values) => {
-    const props = indent(values.map(v => `${transformKey(v)} = ${generateString(v)}`).join(',\n'));
+    const props = indent(values.map((v) => `${transformKey(v)} = ${generateString(v)}`).join(",\n"));
     return `export enum ${name} {\n${props}\n}`;
 };
 
@@ -175,31 +166,34 @@ const generateEnum = (name, values) => {
 const loosePascalCase = (str) => str[0].toUpperCase() + str.slice(1);
 
 const isObject = (v) => {
-    return v !== null && typeof v === 'object' && !Array.isArray(v);
+    return v !== null && typeof v === "object" && !Array.isArray(v);
 };
 const isParameterObject = (v) => {
-    return isObject(v) && typeof v.name === 'string' && typeof v.in === 'string';
+    return isObject(v) && typeof v.name === "string" && typeof v.in === "string";
 };
 const isReferenceObject = (v) => {
-    return isObject(v) && typeof v.$ref === 'string';
+    return isObject(v) && typeof v.$ref === "string";
 };
 const isObjectSchemaObject = (v) => {
-    return isObject(v) && v.type === 'object' && isObject(v.properties);
+    return isObject(v) && v.type === "object" && isObject(v.properties);
 };
 const isEnumSchemaObject = (v) => {
-    return isObject(v) && v.type === 'string' && Array.isArray(v.enum);
+    return isObject(v) && v.type === "string" && Array.isArray(v.enum);
 };
 const isArraySchemaObject = (v) => {
-    return isObject(v) && v.type === 'array' && typeof v.items === 'object';
+    return isObject(v) && v.type === "array" && typeof v.items === "object";
 };
 const isResponseObject = (v) => {
-    return isObject(v) && typeof v.description === 'string';
+    return isObject(v) && typeof v.description === "string";
 };
 const isNonArraySchemaObject = (v) => {
-    return isObject(v) && ['string', 'undefined'].includes(typeof v.type);
+    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']);
+    return (isObject(v) &&
+        isNonArraySchemaObject(v) &&
+        "x-weclapp" in v &&
+        isObject(v["x-weclapp"]));
 };
 
 const generateEnums = (schemas) => {
@@ -210,7 +204,7 @@ const generateEnums = (schemas) => {
             if (!enums.has(name)) {
                 enums.set(name, {
                     properties: schema.enum,
-                    source: generateEnum(name, schema.enum)
+                    source: generateEnum(name, schema.enum),
                 });
             }
         }
@@ -218,57 +212,62 @@ const generateEnums = (schemas) => {
     return enums;
 };
 
-const concat = (strings, separator = ', ', maxLength = 80) => {
+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`;
+            .join(""))}\n`;
     }
     else {
         return joined;
     }
 };
 
-/* eslint-disable no-use-before-define */
 const createReferenceType = (value) => ({
-    type: 'reference',
-    toString: () => loosePascalCase(value)
+    type: "reference",
+    toString: () => loosePascalCase(value),
 });
 const createRawType = (value) => ({
-    type: 'raw',
-    toString: () => value
+    type: "raw",
+    toString: () => value,
 });
 const createArrayType = (value) => ({
-    type: 'array',
-    toString: () => `(${value.toString()})[]`
+    type: "array",
+    toString: () => `(${value.toString()})[]`,
 });
 const createTupleType = (value) => ({
-    type: 'tuple',
-    toString: () => concat([...new Set(value.map(v => typeof v === 'string' ? `'${v}'` : v.toString()))], ' | ')
+    type: "tuple",
+    toString: () => concat([
+        ...new Set(value.map((v) => (typeof v === "string" ? `'${v}'` : v.toString()))),
+    ], " | "),
 });
 const createObjectType = (value, required = []) => ({
-    type: 'object',
+    type: "object",
     isFullyOptional: () => {
-        return !required.length && Object.values(value)
-            .filter(v => v?.type === 'object')
-            .every(v => v.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 => {
+            .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()};`;
+            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}` : '{}';
-    }
+        return properties.length ? `{\n${indent(properties.join("\n"))}\n}` : "{}";
+    },
 });
 const getRefName = (obj) => {
-    return obj.$ref.replace(/.*\//, '');
+    return obj.$ref.replace(/.*\//, "");
 };
 const convertToTypeScriptType = (schema, property) => {
     if (isReferenceObject(schema)) {
@@ -276,27 +275,33 @@ const convertToTypeScriptType = (schema, property) => {
     }
     else {
         switch (schema.type) {
-            case 'integer':
-            case 'number':
-                return createRawType('number');
-            case 'string':
+            case "integer":
+            case "number":
+                return createRawType("number");
+            case "string":
                 if (schema.enum) {
-                    return property ? createReferenceType(property) : createTupleType(schema.enum);
+                    return property
+                        ? createReferenceType(property)
+                        : createTupleType(schema.enum);
                 }
                 else {
-                    return schema.format === 'binary' ? createRawType('binary') : createRawType('string');
+                    return schema.format === "binary"
+                        ? createRawType("binary")
+                        : createRawType("string");
                 }
-            case 'boolean':
-                return createRawType('boolean');
-            case 'object': {
+            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);
+                return createObjectType(Object.fromEntries(Object.entries(properties).map((v) => [
+                    v[0],
+                    convertToTypeScriptType(v[1]),
+                ])), required);
             }
-            case 'array':
+            case "array":
                 return createArrayType(convertToTypeScriptType(schema.items, property));
             default:
-                return createRawType('unknown');
+                return createRawType("unknown");
         }
     }
 };
@@ -312,10 +317,13 @@ const setEntityEnumProperty = (enums, prop, meta) => {
     }
 };
 const extractPropertyMetaData = (enums, meta, prop) => {
-    const result = { service: meta.service, entity: meta.entity };
+    const result = {
+        service: meta.service,
+        entity: meta.entity,
+    };
     if (isReferenceObject(prop)) {
         setEntityEnumProperty(enums, prop, result);
-        result.type = 'reference';
+        result.type = "reference";
         return result;
     }
     result.type = prop.type;
@@ -325,47 +333,47 @@ const extractPropertyMetaData = (enums, meta, prop) => {
     if (isArraySchemaObject(prop)) {
         if (isReferenceObject(prop.items)) {
             setEntityEnumProperty(enums, prop.items, result);
-            result.format = 'reference';
+            result.format = "reference";
         }
         else {
-            result.format = 'string';
+            result.format = "string";
         }
     }
     return result;
 };
 
 const generateInlineComment = (comment) => `/** ${comment} */`;
-const generateBlockComment = (comment, body) => `/**\n${comment.trim().replace(/^ */gm, ' * ')}\n */${body ? `\n${body}` : ''}`;
+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 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)
+        .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 ' : '';
+        const cmd = comment ? `${generateInlineComment(comment)}\n` : "";
+        const req = required ? "" : "?";
+        const rol = readonly ? "readonly " : "";
         return `${cmd + rol + name + req}: ${type};`;
     })
-        .join('\n');
+        .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 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 bases = extend ? arrayify(extend).join(" & ") : undefined;
+    return generateType(name, `${bases ? `${bases} & ` : ""}${body}`);
 };
 
 const generateEntities = (schemas, enums) => {
@@ -387,7 +395,9 @@ const generateEntities = (schemas, enums) => {
         let extend = undefined;
         const processProperties = (props = {}) => {
             for (const [name, property] of Object.entries(props)) {
-                const meta = isRelatedEntitySchema(property) ? property['x-weclapp'] : {};
+                const meta = isRelatedEntitySchema(property)
+                    ? property["x-weclapp"]
+                    : {};
                 if (meta.entity) {
                     const type = `${pascalCase(meta.entity)}[]`;
                     if (schemas.has(meta.entity)) {
@@ -405,14 +415,19 @@ const generateEntities = (schemas, enums) => {
                     }
                 }
                 const type = convertToTypeScriptType(property, name).toString();
-                const comment = isNonArraySchemaObject(property) ?
-                    property.deprecated ? '@deprecated will be removed.' :
-                        property.format ? `format: ${property.format}` :
-                            undefined : undefined;
+                const comment = isNonArraySchemaObject(property)
+                    ? property.deprecated
+                        ? "@deprecated will be removed."
+                        : property.format
+                            ? `format: ${property.format}`
+                            : undefined
+                    : undefined;
                 entityInterface.push({
-                    name, type, comment,
+                    name,
+                    type,
+                    comment,
                     required: meta.required,
-                    readonly: !isReferenceObject(property) && property.readOnly
+                    readonly: !isReferenceObject(property) && property.readOnly,
                 });
                 properties.set(name, extractPropertyMetaData(enums, meta, property));
             }
@@ -432,7 +447,7 @@ const generateEntities = (schemas, enums) => {
         entities.set(schemaName, {
             extends: extend ? camelCase(extend) : extend,
             properties,
-            source
+            source,
         });
     }
     return entities;
@@ -443,20 +458,21 @@ const generateEntities = (schemas, enums) => {
  * @param s String to pluralize.
  */
 const pluralize = (s) => {
-    return s.endsWith('s') ? s :
-        s.endsWith('y') ? `${s.slice(0, -1)}ies` :
-            `${s}s`;
+    return s.endsWith("s")
+        ? s
+        : s.endsWith("y")
+            ? `${s.slice(0, -1)}ies`
+            : `${s}s`;
 };
 
-/* eslint-disable no-console */
-const logger = new class {
+const logger = new (class {
     active = true;
     warnings = 0;
     errors = 0;
-    write(str = '') {
+    write(str = "") {
         process.stdout.write(str);
     }
-    blankLn(str = '') {
+    blankLn(str = "") {
         this.blank(`${str}\n`);
     }
     warnLn(str) {
@@ -478,18 +494,18 @@ const logger = new class {
         this.write(str);
     }
     warn(str) {
-        this.write(`${chalk.yellowBright('[!]')} ${str}`);
+        this.write(`${chalk.yellowBright("[!]")} ${str}`);
         this.warnings++;
     }
     error(str) {
-        this.write(`${chalk.redBright('[X]')} ${str}`);
+        this.write(`${chalk.redBright("[X]")} ${str}`);
         this.errors++;
     }
     success(str) {
-        this.write(`${chalk.greenBright('[✓]')} ${str}`);
+        this.write(`${chalk.greenBright("[✓]")} ${str}`);
     }
     info(str) {
-        this.write(`${chalk.blueBright('[i]')} ${str}`);
+        this.write(`${chalk.blueBright("[i]")} ${str}`);
     }
     debug(str) {
         this.write(`[-] ${str}`);
@@ -497,15 +513,18 @@ const logger = new class {
     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)}`;
+            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 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);
+        this[this.errors ? "errorLn" : this.warnings ? "warnLn" : "successLn"](info);
     }
-};
+})();
 
 /**
  * ROOT           => /article
@@ -523,34 +542,46 @@ var WeclappEndpointType;
     WeclappEndpointType["GENERIC_ENTITY"] = "GENERIC_ENTITY";
 })(WeclappEndpointType || (WeclappEndpointType = {}));
 const parseEndpointPath = (path) => {
-    const [, entity, ...rest] = path.split('/');
+    const [, entity, ...rest] = path.split("/");
     if (!entity) {
         return undefined;
     }
     if (!rest.length) {
         return { path, entity, type: WeclappEndpointType.ROOT };
     }
-    else if (rest[0] === 'count') {
+    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[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 {
+            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 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(', ')})` : `()`;
+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)}`);
 };
 
@@ -558,21 +589,23 @@ const convertParametersToSchema = (parameters = []) => {
     const properties = [];
     const required = [];
     for (const param of parameters) {
-        if (isParameterObject(param) && param.in === 'query') {
+        if (isParameterObject(param) && param.in === "query") {
             if (param.schema) {
                 properties.push([param.name, param.schema]);
-                param.required && required.push(param.name);
+                if (param.required)
+                    required.push(param.name);
             }
         }
     }
     return {
-        type: 'object', required,
-        properties: Object.fromEntries(properties)
+        type: "object",
+        required,
+        properties: Object.fromEntries(properties),
     };
 };
 
-const functionName$5 = 'count';
-const generateCountEndpoint = ({ aliases, path, target, endpoint }) => {
+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`;
@@ -580,18 +613,20 @@ const generateCountEndpoint = ({ aliases, path, target, endpoint }) => {
     const entityParameters = `${interfaceName}_Parameters`;
     const parameterSchema = convertParametersToSchema(path.parameters);
     const parameters = createObjectType({
-        params: convertToTypeScriptType(parameterSchema)
+        params: convertToTypeScriptType(parameterSchema),
     });
     const functionSource = generateArrowFunction({
         name: functionName$5,
         signature: interfaceName,
         returns: `_${functionName$5}(cfg, ${generateString(endpoint.path)}, query)`,
-        params: ['query']
+        params: ["query"],
     });
     const interfaceSource = generateArrowFunctionType({
         type: interfaceName,
-        params: [`query${parameters.isFullyOptional() ? '?' : ''}: CountQuery<${entityFilter}> & ${entityParameters}`],
-        returns: `${resolveResponseType(target)}<number>`
+        params: [
+            `query${parameters.isFullyOptional() ? "?" : ""}: CountQuery<${entityFilter}> & ${entityParameters}`,
+        ],
+        returns: `${resolveResponseType(target)}<number>`,
     });
     return {
         entity,
@@ -601,9 +636,9 @@ const generateCountEndpoint = ({ aliases, path, target, endpoint }) => {
         interfaces: [
             {
                 name: entityParameters,
-                source: generateInterfaceFromObject(entityParameters, parameters, true)
-            }
-        ]
+                source: generateInterfaceFromObject(entityParameters, parameters, true),
+            },
+        ],
     };
 };
 
@@ -620,43 +655,40 @@ const generateBodyType = (body) => {
     return types.length ? createTupleType(types) : undefined;
 };
 
-const generateRequestBodyType = ({ requestBody }) => {
-    return generateBodyType(requestBody) ?? createRawType('unknown');
+const generateRequestBodyType = ({ requestBody, }) => {
+    return generateBodyType(requestBody) ?? createRawType("unknown");
 };
 
-const resolveBodyType = ({ responses }) => Object.entries(responses)
-    .filter(v => v[0].startsWith('2'))[0]?.[1];
-const generateResponseBodyType = (object) => generateBodyType(resolveBodyType(object)) ?? createRawType('void');
+const resolveBodyType = ({ responses, }) => Object.entries(responses).filter((v) => v[0].startsWith("2"))[0]?.[1];
+const generateResponseBodyType = (object) => generateBodyType(resolveBodyType(object)) ?? createRawType("void");
 
-const functionName$4 = 'create';
-const generateCreateEndpoint = ({ target, path, endpoint }) => {
+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']
+        params: ["data"],
     });
     const interfaceSource = generateArrowFunctionType({
         type: interfaceName,
         params: [`data: DeepPartial<${generateRequestBodyType(path).toString()}>`],
-        returns: `${resolveResponseType(target)}<${generateResponseBodyType(path).toString()}>`
+        returns: `${resolveResponseType(target)}<${generateResponseBodyType(path).toString()}>`,
     });
     return {
         entity,
         name: functionName$4,
         type: { name: interfaceName, source: interfaceSource },
-        func: { name: functionName$4, source: functionSource }
+        func: { name: functionName$4, source: functionSource },
     };
 };
 
-const generateGenericFunctionName = (path, suffix = '', prefix = '') => {
+const generateGenericFunctionName = (path, suffix = "", prefix = "") => {
     return camelCase(`${prefix}_` +
-        path
-            .replace(/.*\//, '')
-            .replace(/\W+/, '_')
-            .replace(/[_]+/, '_') + `_${suffix}`);
+        path.replace(/.*\//, "").replace(/\W+/, "_").replace(/[_]+/, "_") +
+        `_${suffix}`);
 };
 
 const insertPathPlaceholder = (path, record) => {
@@ -664,32 +696,37 @@ const insertPathPlaceholder = (path, record) => {
 };
 
 const wrapBody = (type, target) => {
-    return type.toString() === 'binary' ?
-        createRawType(isNodeTarget(target) ? 'BodyInit' : 'Blob') :
-        type; // node-fetch returns a Blob as well
+    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 hasId = endpoint.path.includes("{id}");
     const params = createObjectType({
         params: convertToTypeScriptType(convertParametersToSchema(path.parameters)),
-        body: method === 'get' ? undefined : wrapBody(generateRequestBodyType(path), target)
+        body: method === "get"
+            ? undefined
+            : wrapBody(generateRequestBodyType(path), target),
     });
     const responseBody = generateResponseBodyType(path);
-    const forceBlobResponse = String(responseBody.toString() === 'binary');
+    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})`
+        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()}>`
+        params: [
+            ...(hasId ? ["id: string"] : []),
+            `query${params.isFullyOptional() ? "?" : ""}: ${entityQuery}`,
+        ],
+        returns: `${resolveResponseType(target)}<${wrapBody(responseBody, target).toString()}>`,
     });
     return {
         entity,
@@ -699,44 +736,48 @@ const generateGenericEndpoint = (suffix) => ({ target, method, path, endpoint })
         interfaces: [
             {
                 name: entityQuery,
-                source: generateInterfaceFromObject(entityQuery, params, true)
-            }
-        ]
+                source: generateInterfaceFromObject(entityQuery, params, true),
+            },
+        ],
     };
 };
 
-const functionName$3 = 'remove';
-const generateRemoveEndpoint = ({ target, endpoint }) => {
+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}' })}\`, options)`,
-        params: ['id', 'options?: RemoveQuery']
+        returns: `_${functionName$3}(cfg, \`${insertPathPlaceholder(endpoint.path, { id: "${id}" })}\`, options)`,
+        params: ["id", "options?: RemoveQuery"],
     });
     const interfaceSource = generateArrowFunctionType({
         type: interfaceName,
-        params: ['id: string', 'options?: RemoveQuery'],
-        returns: `${resolveResponseType(target)}<void>`
+        params: ["id: string", "options?: RemoveQuery"],
+        returns: `${resolveResponseType(target)}<void>`,
     });
     return {
         entity,
         name: functionName$3,
         type: { name: interfaceName, source: interfaceSource },
-        func: { name: functionName$3, source: functionSource }
+        func: { name: functionName$3, source: functionSource },
     };
 };
 
-const functionName$2 = 'some';
+const functionName$2 = "some";
 const excludedParameters = [
-    'page', 'pageSize', 'sort',
-    'serializeNulls', 'properties', 'includeReferencedEntities'
+    "page",
+    "pageSize",
+    "sort",
+    "serializeNulls",
+    "properties",
+    "includeReferencedEntities",
 ];
 const resolveAdditionalProperties = (path) => {
     const body = resolveBodyType(path);
     if (isResponseObject(body)) {
-        const schema = body?.content?.['application/json']?.schema;
+        const schema = body?.content?.["application/json"]?.schema;
         if (isObjectSchemaObject(schema)) {
             const obj = schema?.properties?.additionalProperties;
             if (isObjectSchemaObject(obj)) {
@@ -746,7 +787,7 @@ const resolveAdditionalProperties = (path) => {
     }
     return undefined;
 };
-const generateSomeEndpoint = ({ aliases, target, path, endpoint }) => {
+const generateSomeEndpoint = ({ aliases, target, path, endpoint, }) => {
     // Required interface names
     const service = pascalCase(endpoint.entity);
     const entity = aliases.get(endpoint.entity) ?? service;
@@ -758,28 +799,33 @@ const generateSomeEndpoint = ({ aliases, target, path, endpoint }) => {
     const parameterSchema = convertParametersToSchema(path.parameters);
     const additionalProperties = resolveAdditionalProperties(path);
     const additionalPropertyNames = generateStrings(Object.keys(additionalProperties?.properties ?? {}));
-    const additionalPropertyNamesType = additionalPropertyNames.length ? `(${concat(additionalPropertyNames, ' | ')})[]` : '[]';
+    const additionalPropertyNamesType = additionalPropertyNames.length
+        ? `(${concat(additionalPropertyNames, " | ")})[]`
+        : "[]";
     // We already cover some properties
-    parameterSchema.properties = Object.fromEntries(Object.entries(parameterSchema.properties ?? {})
-        .filter(v => !excludedParameters.includes(v[0])));
+    parameterSchema.properties = Object.fromEntries(Object.entries(parameterSchema.properties ?? {}).filter((v) => !excludedParameters.includes(v[0])));
     const parameters = createObjectType({
-        params: convertToTypeScriptType(parameterSchema)
+        params: convertToTypeScriptType(parameterSchema),
     });
-    const properties = additionalProperties ? convertToTypeScriptType(additionalProperties).toString() : '{}';
+    const properties = additionalProperties
+        ? convertToTypeScriptType(additionalProperties).toString()
+        : "{}";
     const interfaceSource = generateArrowFunctionType({
         type: interfaceName,
         generics: [
             `S extends (QuerySelect<${entity}> | undefined) = undefined`,
-            `I extends (QuerySelect<${entityMappings}> | undefined) = undefined`
+            `I extends (QuerySelect<${entityMappings}> | undefined) = undefined`,
         ],
-        params: [`query${parameters.isFullyOptional() ? '?' : ''}: SomeQuery<${entity}, ${entityFilter}, I, S, ${additionalPropertyNamesType}> & ${entityParameters}`],
-        returns: `${resolveResponseType(target)}<SomeQueryReturn<${entity}, ${entityReferences}, ${entityMappings}, I, S, ${properties}>>`
+        params: [
+            `query${parameters.isFullyOptional() ? "?" : ""}: SomeQuery<${entity}, ${entityFilter}, I, S, ${additionalPropertyNamesType}> & ${entityParameters}`,
+        ],
+        returns: `${resolveResponseType(target)}<SomeQueryReturn<${entity}, ${entityReferences}, ${entityMappings}, I, S, ${properties}>>`,
     });
     const functionSource = generateArrowFunction({
         name: functionName$2,
         signature: interfaceName,
         returns: `_${functionName$2}(cfg, ${generateString(endpoint.path)}, query)`,
-        params: ['query']
+        params: ["query"],
     });
     return {
         entity,
@@ -789,62 +835,66 @@ const generateSomeEndpoint = ({ aliases, target, path, endpoint }) => {
         interfaces: [
             {
                 name: entityParameters,
-                source: generateInterfaceFromObject(entityParameters, parameters, true)
-            }
-        ]
+                source: generateInterfaceFromObject(entityParameters, parameters, true),
+            },
+        ],
     };
 };
 
-const functionName$1 = 'unique';
-const generateUniqueEndpoint = ({ target, path, endpoint }) => {
+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)`
+        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()}>`
+        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 }
+        func: { name: functionName$1, source: functionSource },
     };
 };
 
-const functionName = 'update';
-const generateUpdateEndpoint = ({ target, path, endpoint }) => {
+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()}>`
+        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']
+        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 }
+        func: { name: functionName, source: functionSource },
     };
 };
 
 const isMultiPartUploadPath = (path) => {
-    const [, entity, ...rest] = path.split('/');
-    return entity && rest.length === 2 && rest[1] === 'multipartUpload';
+    const [, entity, ...rest] = path.split("/");
+    return entity && rest.length === 2 && rest[1] === "multipartUpload";
 };
 const groupEndpointsByEntity = (paths) => {
     const endpoints = new Map();
@@ -872,28 +922,28 @@ const generators = {
     /* /article */
     [WeclappEndpointType.ROOT]: {
         get: generateSomeEndpoint,
-        post: generateCreateEndpoint
+        post: generateCreateEndpoint,
     },
     /* /article/count */
     [WeclappEndpointType.COUNT]: {
-        get: generateCountEndpoint
+        get: generateCountEndpoint,
     },
     /* /article/:id */
     [WeclappEndpointType.ENTITY]: {
         get: generateUniqueEndpoint,
         delete: generateRemoveEndpoint,
-        put: generateUpdateEndpoint
+        put: generateUpdateEndpoint,
     },
     /* /article/:id/method */
     [WeclappEndpointType.GENERIC_ENTITY]: {
-        get: generateGenericEndpoint('ById'),
-        post: generateGenericEndpoint('ById')
+        get: generateGenericEndpoint("ById"),
+        post: generateGenericEndpoint("ById"),
     },
     /* /article/method */
     [WeclappEndpointType.GENERIC_ROOT]: {
         get: generateGenericEndpoint(),
-        post: generateGenericEndpoint()
-    }
+        post: generateGenericEndpoint(),
+    },
 };
 const generateServices = (doc, aliases, options) => {
     const services = new Map();
@@ -906,7 +956,9 @@ const generateServices = (doc, aliases, options) => {
         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) {
+                if (method === "get" &&
+                    endpoint.type === WeclappEndpointType.ENTITY &&
+                    !options.generateUnique) {
                     continue;
                 }
                 if (resolver[method]) {
@@ -915,7 +967,7 @@ const generateServices = (doc, aliases, options) => {
                     if (!path.deprecated || options.deprecated) {
                         functions.push({
                             ...resolver[method]({ endpoint, method, target, path, aliases }),
-                            path
+                            path,
                         });
                     }
                 }
@@ -928,33 +980,40 @@ const generateServices = (doc, aliases, options) => {
             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 => ({
+        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,
+                comment: v.path.deprecated ? "@deprecated" : undefined,
                 name: v.func.name,
-                type: v.type.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 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 });
+        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 customValueEntity = entities.get("customValue");
     const customValueEntities = [];
     if (!customValueEntity) {
-        logger.warn('Cannot generate custom value utils, type not found.');
-        return '';
+        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');
+        const someFunction = service.functions.find((v) => v.name === "some");
         if (!someFunction) {
             continue;
         }
@@ -969,7 +1028,7 @@ const generateCustomValueUtilities = (entities, services) => {
         }
         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);')}`));
+    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) => {
@@ -988,7 +1047,7 @@ const generateObject = (properties) => {
             body.push(`${key}: ${String(value)}`);
         }
     }
-    return body.length ? `{\n${indent(body.join(',\n'))}\n}` : `{}`;
+    return body.length ? `{\n${indent(body.join(",\n"))}\n}` : `{}`;
 };
 
 const resolveInheritedEntities = (root, entities) => {
@@ -996,34 +1055,42 @@ const resolveInheritedEntities = (root, entities) => {
     return parent ? [parent, ...resolveInheritedEntities(parent, entities)] : [];
 };
 const generatePropertyDescriptors = (entity, entities, services, options) => [
-    ...resolveInheritedEntities(entity, entities).flatMap(v => [...v.properties]),
-    ...entity.properties
-].filter(([, meta]) => {
+    ...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);
+    const service = services.find((v) => v.entity === meta.service);
     return !meta.service || (service && !service.deprecated);
-}).map(([property, meta]) => ({
+})
+    .map(([property, meta]) => ({
     key: property,
     value: Object.entries(meta).map(([key, value]) => ({
         key,
-        value: value !== undefined ? typeof value === 'number' ? value : generateString(value) : undefined
-    }))
+        value: value !== undefined
+            ? typeof value === "number"
+                ? value
+                : generateString(value)
+            : undefined,
+    })),
 }));
 const generateEntityPropertyMap = (entities, services, options) => {
-    const typeName = 'WEntityProperties';
+    const typeName = "WEntityProperties";
     const propertyMap = [...entities].map(([entity, data]) => ({
         key: entity,
-        value: generatePropertyDescriptors(data, entities, services, options)
+        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))))}]`;
+    return `[${concat(values.map((v) => generateString(String(v))))}]`;
 };
 
 // Only functions matching this regex are included in the generation.
@@ -1042,11 +1109,12 @@ const generateGroupedServices = (services) => {
                 continue;
             }
             entityDescriptors.set(name, [
-                ...(entityDescriptors.get(name) ?? []), {
+                ...(entityDescriptors.get(name) ?? []),
+                {
                     name: entity,
                     required: true,
-                    type: `${pascalCase(entity)}Service_${pascalCase(name)}`
-                }
+                    type: `${pascalCase(entity)}Service_${pascalCase(name)}`,
+                },
             ]);
         }
     }
@@ -1064,46 +1132,57 @@ const generateGroupedServices = (services) => {
         ...descriptors.map(([name, props]) => {
             const constant = camelCase(`wServiceWith_${name}_Names`);
             const type = pascalCase(`WServiceWith_${name}`);
-            const value = generateArray(props.map(v => v.name));
+            const value = generateArray(props.map((v) => v.name));
             return `export const ${constant}: ${type}[] = ${value};`;
         }),
-        generateBlockComment('Type guards for service classes.', generateStatements(...typeGuards))
+        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 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 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;
+        return v.deprecated
+            ? generateInlineComment("@deprecated") + `\n${src}`
+            : src;
     }))};`;
     const entityInterfaces = [
-        ...entitiesKeys.map(entity => ({
+        ...entitiesKeys.map((entity) => ({
             name: entity,
             type: pascalCase(entity),
-            required: true
+            required: true,
         })),
-        ...services.map(service => {
+        ...services.map((service) => {
             const alias = aliases.get(service.entity);
             return {
                 name: service.entity,
-                type: alias ?? 'never',
+                type: alias ?? "never",
                 required: true,
-                comment: alias ? undefined : 'no response defined or inlined'
+                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') })));
+    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 */
@@ -1127,16 +1206,15 @@ const generateMaps = ({ services, entities, aliases, enums, options }) => {
                 - 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'), 
+        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))
+        ...generateGroupedServices(services)),
     };
 };
 
-const parseReferencedEntity = (obj) => pascalCase(obj.$ref.replace(/.*\//, ''));
-/* eslint-disable @typescript-eslint/no-unsafe-return */
+const parseReferencedEntity = (obj) => pascalCase(obj.$ref.replace(/.*\//, ""));
 const extractSchemas = (doc) => {
     const schemas = new Map();
     const aliases = new Map();
@@ -1155,7 +1233,7 @@ const extractSchemas = (doc) => {
             continue;
         }
         for (const method of Object.values(OpenAPIV3.HttpMethods)) {
-            const body = methods[method]?.responses['200'];
+            const body = methods[method]?.responses["200"];
             if (isResponseObject(body) && body.content) {
                 const responseSchema = Object.values(body.content)[0]?.schema;
                 if (isReferenceObject(responseSchema)) {
@@ -1183,16 +1261,16 @@ const generate = (doc, options) => {
     const enums = generateEnums(schemas);
     const entities = generateEntities(schemas, enums);
     const services = generateServices(doc, aliases, options);
-    return generateStatements(generateBase(options.target, doc.info.version), 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({
+    return generateStatements(generateBase(options.target, doc.info.version), 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
+        aliases,
     }).source));
 };
 
-const hash = (content, algorithm = 'sha256') => {
+const hash = (content, algorithm = "sha256") => {
     const hash = createHash(algorithm);
     if (Array.isArray(content)) {
         content.map(hash.update.bind(hash));
@@ -1200,99 +1278,103 @@ const hash = (content, algorithm = 'sha256') => {
     else {
         hash.update(content);
     }
-    return hash.digest('hex');
+    return hash.digest("hex");
 };
 
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 const cli = async () => {
-    const { default: { version } } = await import('../package.json', { assert: { type: 'json' } });
+    const version = pkg.version;
     const { argv } = yargs(hideBin(process.argv))
-        .scriptName('build-weclapp-sdk')
-        .usage('Usage: $0 <source> [flags]')
+        .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'
+        .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("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("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("generate-unique", {
+        describe: "Generate .unique functions",
+        type: "boolean",
     })
-        .option('d', {
-        alias: 'deprecated',
-        describe: 'Include deprecated functions and services',
-        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("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("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'
+        .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 { 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
+        target: argv.target ?? Target.BROWSER_PROMISES,
     };
-    if (typeof src === 'number') {
-        return Promise.reject('Expected string as command');
+    if (!src || typeof src === "number") {
+        return Promise.reject(new Error("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();
+        logger.errorLn(`Unknown target: ${options.target}. Possible values are ${Object.values(Target).join(", ")}`);
+        return Promise.reject(new Error());
     }
     if (await stat(src).catch(() => false)) {
-        logger.infoLn(`Source is a file.`);
-        const content = JSON.parse(await readFile(src, 'utf-8'));
+        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}`);
+    logger.infoLn(`Source is a URL`);
+    if (!key) {
+        return Promise.reject(new Error("API key is missing"));
+    }
+    const url = new URL(src.startsWith("http") ? src : `https://${src}`);
     // At the moment just v1
-    url.pathname = '/webapp/api/v1/meta/openapi.json';
+    url.pathname = "/webapp/api/v1/meta/openapi.json";
     if (query?.length) {
-        for (const param of query.split(',')) {
-            const [name, value] = param.split('=');
+        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);
+        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();
+        return Promise.reject(new Error());
     }
     else {
         logger.infoLn(`Use remote file: ${url.toString()}`);
@@ -1300,50 +1382,61 @@ const cli = async () => {
     return { cache, content, options };
 };
 
-const workingDirectory = resolve(currentDirname(), './sdk');
-const folders = ['docs', 'main', 'node', 'raw', 'rx', 'utils'];
+const workingDir = resolve(currentDirname(), "./sdk");
+const cacheDir = resolve(currentDirname(), "./.cache");
 void (async () => {
     const start = process.hrtime.bigint();
-    const { default: { version } } = await import('../package.json', { assert: { type: 'json' } });
     const { content: doc, cache: useCache, options } = await cli();
-    // Resolve cache dir and key
-    const cacheKey = hash([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);
+    const workingDirPath = async (...paths) => {
+        const fullPath = resolve(workingDir, ...paths);
+        await mkdir(dirname(fullPath), { recursive: true });
         return fullPath;
     };
+    // Resolve cache dir and key
+    const cacheKey = hash([
+        pkg.version,
+        JSON.stringify(doc),
+        JSON.stringify(options),
+    ]).slice(-8);
+    const cachedSdkDir = resolve(cacheDir, cacheKey);
+    // Remove old SDK
+    await rm(workingDir, { recursive: true, force: true });
     if (useCache) {
         logger.infoLn(`Cache ID: ${cacheKey}`);
     }
-    if (useCache && await stat(cacheDir).catch(() => false)) {
-        logger.successLn(`Cache match! (${cacheDir})`);
+    if (useCache && (await stat(cachedSdkDir).catch(() => false))) {
+        // Copy cached SDK to working dir
+        logger.successLn(`Cache match! (${cachedSdkDir})`);
+        await cp(cachedSdkDir, workingDir, { recursive: true });
     }
     else {
-        // Store swagger.json file
-        await writeFile(await tmp('openapi.json'), JSON.stringify(doc, null, 2));
+        // Write swagger.json file
+        await writeFile(await workingDirPath("openapi.json"), JSON.stringify(doc, null, 2));
         logger.infoLn(`Generate sdk (target: ${options.target})`);
-        // Generate SDKs
+        // Generate and write SDK
         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)));
+        await writeFile(await workingDirPath("src", "index.ts"), sdk.trim() + "\n");
+        // Bundle and write SDK
+        logger.infoLn("Bundle... (this may take some time)");
+        await bundle(workingDir, options.target);
+        if (useCache) {
+            // Copy SDK to cache
+            logger.successLn(`Caching SDK: (${cachedSdkDir})`);
+            await mkdir(cachedSdkDir, { recursive: true });
+            await cp(workingDir, cachedSdkDir, { recursive: true });
+        }
     }
-    // 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) => {
+})()
+    .catch((error) => {
     logger.errorLn(`Fatal error:`);
     /* eslint-disable no-console */
     console.error(error);
-}).finally(() => {
-    logger.errors && process.exit(1);
+})
+    .finally(() => {
+    if (logger.errors)
+        process.exit(1);
 });