@opra/cli 0.14.2 → 0.15.0

package/esm/api-exporter/index.js

@@ -0,0 +1 @@
+export * from './api-exporter.js';

package/esm/api-exporter/process-resources.d.ts

@@ -0,0 +1,6 @@
+import type { ApiExporter } from './api-exporter.js';
+/**
+ *
+ * @param targetDir
+ */
+export declare function processResources(this: ApiExporter, targetDir?: string): Promise<void>;

package/esm/api-exporter/process-resources.js

@@ -0,0 +1,45 @@
+import chalk from 'chalk';
+import path from 'node:path';
+import { Collection, joinPath, Singleton } from '@opra/common';
+import { wrapJSDocString } from '../utils/string-utils.js';
+/**
+ *
+ * @param targetDir
+ */
+export async function processResources(targetDir = '') {
+    this.logger.log(chalk.yellow('Processing resources'));
+    const { document } = this;
+    const serviceTs = this.addFile(path.join(targetDir, this.name + '.ts'));
+    serviceTs.addImportPackage('@opra/client', ['HttpServiceBase']);
+    const indexTs = this.addFile('/index.ts', true);
+    indexTs.addExportFile(serviceTs.filename);
+    serviceTs.content = `\nexport class ${this.name} extends HttpServiceBase {\n`;
+    for (const resource of document.resources.values()) {
+        serviceTs.content += `\n/**\n * ${wrapJSDocString(resource.description || resource.name)}
+ * @url ${joinPath(this.client.serviceUrl, '$metadata#resources/' + resource.name)}
+ */`;
+        if (resource instanceof Collection) {
+            const typeName = resource.type.name || '';
+            serviceTs.addImportPackage('@opra/client', ['HttpCollectionNode']);
+            serviceTs.addImportFile('types/' + typeName, [typeName]);
+            const operations = Object.keys(resource.operations)
+                .map(x => `'${x}'`).join(' | ');
+            serviceTs.content += `
+  get ${resource.name}(): Pick<HttpCollectionNode<${typeName}>, ${operations}> {
+    return this.$client.collection('${resource.name}');
+  }\n`;
+        }
+        else if (resource instanceof Singleton) {
+            const typeName = resource.type.name || '';
+            serviceTs.addImportPackage('@opra/client', ['HttpSingletonNode']);
+            serviceTs.addImportFile('types/' + typeName, [typeName]);
+            const operations = Object.keys(resource.operations)
+                .map(x => `'${x}'`).join(' | ');
+            serviceTs.content += `
+  get ${resource.name}(): Pick<HttpSingletonNode<${typeName}>, ${operations}> {
+    return this.$client.singleton('${resource.name}');
+  }\n`;
+        }
+    }
+    serviceTs.content += '}';
+}

package/esm/api-exporter/process-types.d.ts

@@ -0,0 +1,54 @@
+import { ComplexType, DataType, EnumType, MappedType, SimpleType, UnionType } from '@opra/common';
+import type { ApiExporter } from './api-exporter.js';
+import { TsFile } from './ts-file.js';
+/**
+ *
+ * @param targetDir
+ */
+export declare function processTypes(this: ApiExporter, targetDir?: string): Promise<void>;
+/**
+ *
+ * @param dataType
+ * @param targetDir
+ */
+export declare function generateTypeFile(this: ApiExporter, dataType: DataType, targetDir?: string): Promise<TsFile>;
+/**
+ *
+ * @param file
+ * @param dataType
+ * @param forInterface
+ */
+export declare function resolveTypeNameOrDef(this: ApiExporter, file: TsFile, dataType: DataType, forInterface?: boolean): Promise<string>;
+/**
+ *
+ * @param file
+ * @param dataType
+ * @param forInterface
+ */
+export declare function generateComplexTypeDefinition(this: ApiExporter, file: TsFile, dataType: ComplexType, forInterface?: boolean): Promise<string>;
+/**
+ *
+ * @param file
+ * @param dataType
+ */
+export declare function generateSimpleTypeDefinition(this: ApiExporter, file: TsFile, dataType: SimpleType): Promise<string>;
+/**
+ *
+ * @param file
+ * @param dataType
+ */
+export declare function generateEnumTypeDefinition(this: ApiExporter, file: TsFile, dataType: EnumType): Promise<string>;
+/**
+ *
+ * @param file
+ * @param dataType
+ * @param forInterface
+ */
+export declare function generateUnionTypeDefinition(this: ApiExporter, file: TsFile, dataType: UnionType, forInterface?: boolean): Promise<string>;
+/**
+ *
+ * @param file
+ * @param dataType
+ * @param forInterface
+ */
+export declare function generateMappedTypeDefinition(this: ApiExporter, file: TsFile, dataType: MappedType, forInterface?: boolean): Promise<string>;

package/esm/api-exporter/process-types.js

@@ -0,0 +1,203 @@
+import chalk from 'chalk';
+import path from 'node:path';
+import { ComplexType, EnumType, joinPath, MappedType, SimpleType, UnionType } from '@opra/common';
+import { wrapJSDocString } from '../utils/string-utils.js';
+const internalTypeNames = ['boolean', 'bigint', 'number', 'null', 'string'];
+/**
+ *
+ * @param targetDir
+ */
+export async function processTypes(targetDir = '') {
+    this.logger.log(chalk.yellow('Processing types'));
+    const { document } = this;
+    const typesTs = this.addFile(path.join(targetDir, 'types.ts'));
+    for (const dataType of document.types.values()) {
+        const expFile = await this.generateTypeFile(dataType, targetDir);
+        typesTs.addExportFile(expFile.filename);
+    }
+}
+/**
+ *
+ * @param dataType
+ * @param targetDir
+ */
+export async function generateTypeFile(dataType, targetDir = '') {
+    const typeName = dataType.name;
+    if (!typeName)
+        throw new TypeError(`DataType has no name`);
+    let filePath;
+    if (dataType instanceof SimpleType)
+        filePath = '/simple-types.ts';
+    else if (dataType instanceof ComplexType)
+        filePath = `/types/${typeName}.ts`;
+    else if (dataType instanceof EnumType) {
+        filePath = `/enums/${typeName}.ts`;
+    }
+    else
+        throw new TypeError(`Unimplemented DataType (${dataType.kind})`);
+    const file = this.addFile(path.join(targetDir, filePath), true);
+    if (file.exportTypes.includes(typeName))
+        return file;
+    file.exportTypes.push(typeName);
+    const indexTs = this.addFile('/index.ts', true);
+    indexTs.addExportFile(file.filename);
+    file.content += `\n/**\n * ${wrapJSDocString(dataType.description || typeName)}
+ * @type ${typeName}
+ * @kind ${dataType.kind}
+ * @url ${joinPath(this.client.serviceUrl, '$metadata#types/' + typeName)}
+ */\n`;
+    if (dataType instanceof SimpleType) {
+        file.content += `export type ${typeName} = ` + await this.generateSimpleTypeDefinition(file, dataType);
+    }
+    else if (dataType instanceof EnumType) {
+        file.content += `export enum ${typeName} ` + await this.generateEnumTypeDefinition(file, dataType);
+    }
+    else if (dataType instanceof ComplexType) {
+        file.content += `export class ${typeName} {
+  constructor(init?: Partial<I${typeName}>) {
+    if (init)
+     Object.assign(this, init);
+  }
+}
+
+export interface ${typeName} extends I${typeName} {
+}
+
+interface I${typeName} ${await this.generateComplexTypeDefinition(file, dataType, true)}
+`;
+    }
+    return file;
+}
+/**
+ *
+ * @param file
+ * @param dataType
+ * @param forInterface
+ */
+export async function resolveTypeNameOrDef(file, dataType, forInterface) {
+    if (dataType.name) {
+        if (internalTypeNames.includes(dataType.name))
+            return dataType.name;
+        const f = await this.generateTypeFile(dataType);
+        file.addImportFile(f.filename, [dataType.name]);
+        return dataType.name;
+    }
+    if (dataType instanceof ComplexType)
+        return this.generateComplexTypeDefinition(file, dataType, forInterface);
+    if (dataType instanceof SimpleType)
+        return this.generateSimpleTypeDefinition(file, dataType);
+    if (dataType instanceof EnumType)
+        return this.generateEnumTypeDefinition(file, dataType);
+    if (dataType instanceof UnionType)
+        return this.generateUnionTypeDefinition(file, dataType, forInterface);
+    if (dataType instanceof MappedType)
+        return this.generateMappedTypeDefinition(file, dataType, forInterface);
+    return 'xxx';
+}
+/**
+ *
+ * @param file
+ * @param dataType
+ * @param forInterface
+ */
+export async function generateComplexTypeDefinition(file, dataType, forInterface) {
+    let out = '';
+    if (dataType.base) {
+        const base = await this.resolveTypeNameOrDef(file, dataType.base, forInterface);
+        out += forInterface ? `extends ${base} ` : `${base} & `;
+    }
+    out += '{\n\n\t';
+    for (const field of dataType.own.fields.values()) {
+        // Print JSDoc
+        let jsDoc = '';
+        if (field.description)
+            jsDoc += ` * ${field.description}\n`;
+        if (field.default)
+            jsDoc += ` * @default ` + field.default + '\n';
+        if (field.format)
+            jsDoc += ` * @format ` + field.format + '\n';
+        if (field.exclusive)
+            jsDoc += ` * @exclusive\n`;
+        if (field.deprecated)
+            jsDoc += ` * @deprecated ` + (typeof field.deprecated === 'string' ? field.deprecated : '') + '\n';
+        if (jsDoc)
+            out += `/**\n${jsDoc}*/\n`;
+        // Print field name
+        out += `${field.name}${field.required ? '' : '?'}: `;
+        if (field.fixed)
+            out += `${field.fixed}`;
+        else {
+            out += await this.resolveTypeNameOrDef(file, field.type) +
+                `${field.isArray ? '[]' : ''};\n\n`;
+        }
+    }
+    if (dataType.additionalFields)
+        out += '[key: string]: any;\n';
+    return out + '\b}';
+}
+/**
+ *
+ * @param file
+ * @param dataType
+ */
+export async function generateSimpleTypeDefinition(file, dataType) {
+    if (dataType.ctor === Boolean)
+        return 'boolean';
+    if (dataType.ctor === String)
+        return 'string';
+    if (dataType.ctor === Number)
+        return 'number';
+    if (dataType.ctor === Date)
+        return 'Date';
+    if (dataType.extendsFrom('bigint'))
+        return 'Date';
+    if (dataType.extendsFrom('object'))
+        return 'object';
+    return 'any';
+}
+/**
+ *
+ * @param file
+ * @param dataType
+ */
+export async function generateEnumTypeDefinition(file, dataType) {
+    let out = '{\n\t';
+    for (const [k, v] of Object.entries(dataType.values)) {
+        // Print JSDoc
+        let jsDoc = '';
+        if (dataType.meanings[k])
+            jsDoc += ` * ${dataType.meanings[k]}\n`;
+        if (jsDoc)
+            out += `/**\n${jsDoc}*/\n`;
+        out += `${k}`;
+        if (v)
+            out += ' = ' + (typeof v === 'number' ? v : ('"' + ('' + v).replace('"', '\\"')) + '"');
+        out += ',\n\n';
+    }
+    return out + '\b}';
+}
+/**
+ *
+ * @param file
+ * @param dataType
+ * @param forInterface
+ */
+export async function generateUnionTypeDefinition(file, dataType, forInterface) {
+    // let out = '';
+    return (await Promise.all(dataType.types
+        .map(t => this.resolveTypeNameOrDef(file, t, forInterface)))).join(forInterface ? ', ' : ' & ');
+}
+/**
+ *
+ * @param file
+ * @param dataType
+ * @param forInterface
+ */
+export async function generateMappedTypeDefinition(file, dataType, forInterface) {
+    return (dataType.pick ? 'Pick<' : 'Omit<') +
+        (await this.resolveTypeNameOrDef(file, dataType.type, forInterface)) +
+        ', ' +
+        (dataType.pick || dataType.omit || [])
+            .map(x => `'${x}'`).join(' | ') +
+        '>';
+}

package/esm/api-exporter/ts-file.d.ts

@@ -0,0 +1,18 @@
+export declare class TsFile {
+    filename: string;
+    dirname: string;
+    importFiles: Record<string, string[]>;
+    exportFiles: Record<string, string[]>;
+    exportTypes: string[];
+    header: string;
+    content: string;
+    constructor(filename: string);
+    addImportPackage: (name: string, types?: string[]) => void;
+    addImportFile: (filename: string, types?: string[]) => void;
+    addExportFile: (filename: string, types?: string[]) => void;
+    generate(options?: {
+        importExt?: string;
+    }): string;
+}
+export declare function relativePath(from: string, to: string): string;
+export declare function setExt(filename: string, ext: string): string;

package/esm/api-exporter/ts-file.js

@@ -0,0 +1,83 @@
+import path from 'path';
+import flattenText from 'putil-flattentext';
+export class TsFile {
+    constructor(filename) {
+        this.filename = filename;
+        this.importFiles = {};
+        this.exportFiles = {};
+        this.exportTypes = [];
+        this.header = '';
+        this.content = '';
+        this.addImportPackage = (name, types) => {
+            this.importFiles[name] = this.importFiles[name] || [];
+            types?.forEach(x => {
+                if (!this.importFiles[name].includes(x))
+                    this.importFiles[name].push(x);
+            });
+        };
+        this.addImportFile = (filename, types) => {
+            filename = path.resolve(this.dirname, filename);
+            this.importFiles[filename] = this.importFiles[filename] || [];
+            types?.forEach(x => {
+                if (!this.importFiles[filename].includes(x))
+                    this.importFiles[filename].push(x);
+            });
+        };
+        this.addExportFile = (filename, types) => {
+            filename = path.resolve(this.dirname, filename);
+            if (filename.endsWith('.ts') || filename.endsWith('.js'))
+                filename = setExt(filename, '');
+            this.exportFiles[filename] = this.exportFiles[filename] || [];
+            types?.forEach(x => {
+                if (!this.exportFiles[filename].includes(x))
+                    this.exportFiles[filename].push(x);
+            });
+        };
+        this.dirname = path.dirname(filename);
+    }
+    generate(options) {
+        const dirname = path.dirname(this.filename);
+        let output = '/* #!oprimp_auto_generated!# !! Do NOT remove this line */\n' +
+            (this.header ? flattenText(this.header) + '\n\n' : '\n');
+        const importStr = Object.keys(this.importFiles)
+            .sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()))
+            .map(filename => {
+            const types = this.importFiles[filename];
+            let relFile = filename;
+            if (path.isAbsolute(filename)) {
+                relFile = relativePath(dirname, filename);
+                if (options?.importExt)
+                    relFile = setExt(relFile, options.importExt);
+            }
+            return `import ${types.length ? '{' + types.join(', ') + '} from ' : ''}'${relFile}';`;
+        })
+            .join('\n');
+        if (importStr)
+            output += flattenText(importStr) + '\n';
+        output += flattenText(this.content);
+        const exportStr = Object.keys(this.exportFiles)
+            .sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()))
+            .map(filename => {
+            const types = this.exportFiles[filename];
+            let relFile = filename;
+            if (path.isAbsolute(filename)) {
+                relFile = relativePath(dirname, filename);
+                if (options?.importExt)
+                    relFile = setExt(relFile, options.importExt);
+            }
+            return `export ${types.length ? '{' + types.join(', ') + '}' : '*'} from '${relFile}';`;
+        })
+            .join('\n');
+        if (exportStr)
+            output += flattenText(exportStr) + '\n';
+        return output;
+    }
+}
+export function relativePath(from, to) {
+    const s = path.relative(from, to);
+    return s.startsWith('.') ? s : ('./' + s);
+}
+export function setExt(filename, ext) {
+    const e = path.extname(filename);
+    return filename.substring(0, filename.length - e.length) + (ext ? '.' + ext : '');
+}

package/esm/index.d.ts

@@ -1 +1 @@
-export * from './oprimp/index.js';
+export * from './api-exporter/index.js';

package/esm/index.js

@@ -1 +1 @@
-export * from './oprimp/index.js';
+export * from './api-exporter/index.js';

package/esm/interfaces/service-generation-context.interface.d.ts

@@ -1,9 +1,9 @@
-import { OpraDocument } from '@opra/common';
+import { ApiDocument } from '@opra/common';
 import { IFileWriter } from './file-writer.interface.js';
 import { ILogger } from './logger.interface.js';
 export interface ServiceGenerationContext {
     serviceUrl: string;
-    document: OpraDocument;
+    document: ApiDocument;
     name: string;
     cwd: string;
     logger: ILogger;

package/esm/{oprimp.js → oprimp-cli.js}

@@ -4,9 +4,10 @@ import * as console from 'console';
 import * as fs from 'fs';
 import path from 'path';
 import * as process from 'process';
-import { generateService } from './oprimp/generate-service.js';
+import { ApiExporter } from './api-exporter/api-exporter.js';
 import { getCallerFile } from './utils/get-caller-file.util.js';
-const pkgJson = JSON.parse(fs.readFileSync(path.resolve(path.dirname(getCallerFile()), '../package.json'), 'utf-8'));
+const dirname = path.dirname(getCallerFile());
+const pkgJson = JSON.parse(fs.readFileSync(path.resolve(dirname, '../package.json'), 'utf-8'));
 program
     .version(pkgJson.version)
     .argument('<serviceUrl>', 'OPRA service url')
@@ -17,16 +18,14 @@ program
     .action(async (serviceUrl, outDir, options) => {
     if (!options.color)
         chalk.level = 0;
-    await generateService({
+    await ApiExporter.execute({
         serviceUrl,
+        logger: console,
         outDir,
         name: options.name,
-        extension: (options.ext ? '.js' : ''),
-        fileHeader: '/*\n' +
-            ' * Generated by OPRA Service Generator \n' +
-            ' * Version: ' + pkgJson.version + '\n' +
-            ' * ' + new Date() + '\n' +
-            ' */'
+        importExt: (options.ext ? 'js' : ''),
+        fileHeader: '/* Generated by OPRA Service Generator, Version ' + pkgJson.version + '*/\n' +
+            '/* eslint-disable import/extensions,simple-import-sort/imports */\n'
     });
     console.log(chalk.greenBright('Completed'));
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/cli",
-  "version": "0.14.2",
+  "version": "0.15.0",
   "description": "Opra CLI tools",
   "author": "Panates",
   "license": "MIT",
@@ -20,22 +20,21 @@
     "copy:bin": "cp -R bin ../../build/cli/bin",
     "lint": "eslint . --max-warnings=0",
     "check": "madge --circular src/**",
-    "test": "NODE_OPTIONS=--experimental-vm-modules npx jest",
-    "cover": "NODE_OPTIONS=--experimental-vm-modules npx jest --collect-coverage",
+    "test": "jest",
+    "cover": "jest --collect-coverage",
     "clean": "npm run clean:src && npm run clean:dist && npm run clean:cover",
     "clean:src": "ts-cleanup -s src --all",
     "clean:dist": "rimraf ../../build/cli ../../build/client",
     "clean:cover": "rimraf ../../coverage/client"
   },
   "dependencies": {
-    "@opra/node-client": "^0.14.0",
+    "@opra/node-client": "^0.15.0",
     "chalk": "^5.2.0",
-    "commander": "^10.0.0",
+    "commander": "^10.0.1",
+    "js-string-escape": "^1.0.1",
     "putil-flattentext": "^2.1.1",
-    "putil-varhelpers": "^1.6.5",
-    "js-string-escape": "^1.0.1"
+    "putil-varhelpers": "^1.6.5"
   },
-  "devDependencies": {},
   "type": "module",
   "types": "esm/index.d.ts",
   "exports": {
@@ -64,4 +63,4 @@
     "tool",
     "oprimp"
   ]
-}
+}

package/cjs/oprimp/delete-files.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteFiles = void 0;
-const tslib_1 = require("tslib");
-const fs_1 = tslib_1.__importDefault(require("fs"));
-const path_1 = tslib_1.__importDefault(require("path"));
-function deleteFiles(dirname) {
-    if (!fs_1.default.existsSync(dirname))
-        return;
-    const files = fs_1.default.readdirSync(dirname);
-    for (const f of files) {
-        const filename = path_1.default.join(dirname, f);
-        if (fs_1.default.statSync(filename).isDirectory()) {
-            deleteFiles(filename);
-            if (!fs_1.default.readdirSync(filename).length)
-                fs_1.default.rmdirSync(filename);
-            continue;
-        }
-        if (path_1.default.extname(f) === '.ts') {
-            const contents = fs_1.default.readFileSync(filename, 'utf-8');
-            if (contents.includes('#!oprimp_auto_generated!#')) {
-                fs_1.default.unlinkSync(filename);
-            }
-        }
-    }
-}
-exports.deleteFiles = deleteFiles;

package/cjs/oprimp/generate-service.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateService = void 0;
-const tslib_1 = require("tslib");
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const console_1 = tslib_1.__importDefault(require("console"));
-const fs = tslib_1.__importStar(require("fs"));
-const path_1 = tslib_1.__importDefault(require("path"));
-const process = tslib_1.__importStar(require("process"));
-const node_client_1 = require("@opra/node-client");
-const ts_file_js_1 = require("../utils/ts-file.js");
-const delete_files_js_1 = require("./delete-files.js");
-const file_writer_js_1 = require("./file-writer.js");
-const process_resoruces_js_1 = require("./process-resoruces.js");
-const process_types_js_1 = require("./process-types.js");
-async function generateService(config) {
-    const cwd = config.cwd || process.cwd();
-    const logger = config.logger || console_1.default;
-    try {
-        console_1.default.log(chalk_1.default.yellow('Fetching service metadata from'), chalk_1.default.whiteBright(config.serviceUrl));
-        const client = await node_client_1.OpraHttpClient.create(config.serviceUrl);
-        const metadata = client.metadata;
-        console_1.default.log(chalk_1.default.yellow('Retrieved service info:'), chalk_1.default.whiteBright(metadata.info.title), '-', chalk_1.default.whiteBright(metadata.info.version));
-        console_1.default.log(chalk_1.default.yellow('Removing old files..'));
-        (0, delete_files_js_1.deleteFiles)(config.outDir);
-        let name = (metadata.info.title || 'Service1').replace(/[^\w_$]*/g, '');
-        name = name.charAt(0).toUpperCase() + name.substring(1);
-        const ctx = {
-            serviceUrl: config.serviceUrl,
-            document: client.metadata,
-            name,
-            logger,
-            cwd,
-            relativeDir: config.outDir,
-            absoluteDir: path_1.default.resolve(cwd, config.outDir),
-            fileHeader: config.fileHeader || '',
-            extension: config.extension,
-            writer: config.writer || new file_writer_js_1.FileWriter()
-        };
-        fs.mkdirSync(ctx.absoluteDir, { recursive: true });
-        await (0, process_types_js_1.processTypes)(ctx);
-        await (0, process_resoruces_js_1.processResources)(ctx);
-        const indexTs = new ts_file_js_1.TsFile();
-        indexTs.header = ctx.fileHeader;
-        indexTs.addExport('./' + ctx.name + ctx.extension);
-        indexTs.addExport('./types' + ctx.extension);
-        await indexTs.writeFile(ctx, path_1.default.join(ctx.absoluteDir, 'index.ts'));
-    }
-    catch (error) {
-        logger.error(chalk_1.default.red(error.message));
-        process.exit(1);
-    }
-}
-exports.generateService = generateService;

package/cjs/oprimp/process-resoruces.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.processResources = void 0;
-const tslib_1 = require("tslib");
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const path_1 = tslib_1.__importDefault(require("path"));
-const common_1 = require("@opra/common");
-const string_utils_js_1 = require("../utils/string-utils.js");
-const ts_file_js_1 = require("../utils/ts-file.js");
-async function processResources(ctx) {
-    const targetDir = ctx.absoluteDir;
-    ctx.logger.log(chalk_1.default.yellow('Processing resources'));
-    const serviceTs = new ts_file_js_1.TsFile();
-    serviceTs.header = ctx.fileHeader;
-    serviceTs.addImport('@opra/client', 'OpraHttpClient');
-    serviceTs.content = `
-const kClient = Symbol('client');
-  
-export class ${ctx.name} {
-  static kClient = kClient;
-  [kClient]: OpraHttpClient;
-  
-  constructor(client: OpraHttpClient) {
-    this[kClient] = client;
-  }
-  `;
-    const resourceNames = Array.from(ctx.document.resources.keys()).sort();
-    for (const resourceName of resourceNames) {
-        const resource = ctx.document.getResource(resourceName);
-        serviceTs.content += `\n/**\n * ${(0, string_utils_js_1.wrapJSDocString)(resource.description || resource.name)}
- * @url ${(0, common_1.joinPath)(ctx.serviceUrl, '$metadata/resources/' + resource.name)}
- */`;
-        if (resource instanceof common_1.CollectionResourceInfo) {
-            serviceTs.addImport('@opra/client', 'HttpCollectionService');
-            serviceTs.addImport('./types/' + resource.dataType.name + ctx.extension, resource.dataType.name);
-            const methods = resource.getHandlerNames()
-                .filter(x => x !== 'count')
-                .map(x => `'${x}'`).join(' | ');
-            serviceTs.content += `
-  get ${resource.name}(): Pick<HttpCollectionService<${resource.dataType.name}, never>, ${methods}> {
-    return this[kClient].collection('${resource.name}');
-  }\n`;
-        }
-        else if (resource instanceof common_1.SingletonResourceInfo) {
-            serviceTs.addImport('@opra/client', 'HttpSingletonService');
-            serviceTs.addImport('./types/' + resource.dataType.name + ctx.extension, resource.dataType.name);
-            const methods = resource.getHandlerNames()
-                .map(x => `'${x}'`).join(' | ');
-            serviceTs.content += `
-  get ${resource.name}(): Pick<HttpSingletonService<${resource.dataType.name}, never>, ${methods}> {
-    return this[kClient].singleton('${resource.name}');
-  }\n`;
-        }
-    }
-    serviceTs.content += `
-}\n`;
-    await serviceTs.writeFile(ctx, path_1.default.join(targetDir, ctx.name + '.ts'));
-}
-exports.processResources = processResources;