@scaleway/generate-react-sdk 0.2.3 → 0.2.4

package/dist/buildAPI.js

@@ -12,7 +12,7 @@ const dirGenName = cliArgs['dir-gen-name'] || 'src/__generated__';
 const sdkFactoryPath = cliArgs['sdk-factory-path'] ||
     '../contexts/SDKCacheProvider/sdkFactory';
 const packageNameFilter = cliArgs['package-name-filter'] || '@scaleway/sdk-';
-generateAPI({
+await generateAPI({
     dirGenName,
     sdkFactoryPath,
     packageNameFilter,

package/dist/generateAPI/emitFiles.d.ts

@@ -1,6 +1,6 @@
-import type { ProcessDeclaration } from './types.ts';
+import type { ProcessedMetadata } from '../metadata-types.ts';
 export declare const emitFiles: ({ res, sourceFolderGen, sdkFactoryPath, }: {
-    res: ProcessDeclaration;
+    res: ProcessedMetadata;
     sourceFolderGen: string;
     sdkFactoryPath: string;
 }) => void;

package/dist/generateAPI/{generate.d.ts → generate-metadata.d.ts}

@@ -1,9 +1,5 @@
-export declare const directoryOfSrcFolder: string;
 export declare const generateAPI: ({ dirGenName, sdkFactoryPath, packageNameFilter, }: {
     dirGenName: string;
     sdkFactoryPath: string;
-    /**
-     * Name of the package starting with
-     */
     packageNameFilter: string;
-}) => void;
+}) => Promise<void>;

package/dist/generateAPI/generate-metadata.js

@@ -0,0 +1,122 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { exec } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join, resolve } from 'node:path';
+import { exit, stdout } from 'node:process';
+import { emitFiles } from './emitFiles.js';
+import { generateType } from './generateType.js';
+const directoryOfSrcFolder = resolve('./');
+const require = createRequire(resolve('./package.json'));
+function discoverSdkPackages(packageNameFilter) {
+    const pkgJsonPath = resolve('package.json');
+    if (!existsSync(pkgJsonPath)) {
+        stdout.write('⚠️  No package.json found in current directory\n');
+        return new Map();
+    }
+    const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+    const allDeps = {
+        ...pkgJson.dependencies,
+        ...pkgJson.devDependencies,
+        ...pkgJson.peerDependencies,
+    };
+    const packages = new Map();
+    for (const [name] of Object.entries(allDeps)) {
+        if (name.startsWith(packageNameFilter)) {
+            packages.set(name, name);
+        }
+    }
+    return packages;
+}
+async function loadVersions(packageName) {
+    try {
+        const resolvedPath = require.resolve(`${packageName}/metadata`);
+        const metadataModule = await import(__rewriteRelativeImportExtension(resolvedPath));
+        const versions = metadataModule?.pkgMetadata?.versions ||
+            metadataModule?.default?.versions ||
+            [];
+        return versions;
+    }
+    catch (error) {
+        stdout.write(`⚠️  Could not load metadata from ${packageName}: ${error}\n`);
+        return [];
+    }
+}
+async function loadMetadata(packageName, version) {
+    try {
+        // Try the exported path first
+        try {
+            const resolvedPath = require.resolve(`${packageName}/${version}/metadata`);
+            const metadataModule = await import(__rewriteRelativeImportExtension(resolvedPath));
+            return metadataModule.queriesMetadata;
+        }
+        catch {
+            stdout.write(`⚠️  Error loading metadata from ${packageName}/${version}/metadata \n Using dist fallback \n`);
+            // Fallback: construct path from node_modules
+            const pkgDir = join(dirname(resolve('package.json')), 'node_modules', packageName);
+            const distMetadataPath = join(pkgDir, 'dist', version, 'metadata.gen.js');
+            const metadataModule = await import(__rewriteRelativeImportExtension(distMetadataPath));
+            return metadataModule.queriesMetadata;
+        }
+    }
+    catch (error) {
+        stdout.write(`⚠️  Error loading metadata from ${packageName}/${version}/metadata: ${error}\n`);
+        return null;
+    }
+}
+export const generateAPI = async ({ dirGenName, sdkFactoryPath, packageNameFilter, }) => {
+    let result = {};
+    const dir = join(directoryOfSrcFolder, dirGenName);
+    // Create directory if it doesn't exist (don't delete existing files)
+    mkdirSync(dir, { recursive: true });
+    const sdkPackages = discoverSdkPackages(packageNameFilter);
+    if (sdkPackages.size === 0) {
+        stdout.write('⚠️  No SDK packages found in dependencies\n');
+    }
+    const skipPackages = new Set(['@scaleway/sdk-test', '@scaleway/sdk-std']);
+    for (const [packageName] of sdkPackages) {
+        if (skipPackages.has(packageName)) {
+            stdout.write(`⚠️  Skipping ${packageName}: excluded package\n`);
+            continue;
+        }
+        const versions = await loadVersions(packageName);
+        if (versions.length === 0) {
+            stdout.write(`⚠️  Skipping ${packageName}: no versions with metadata found\n`);
+            continue;
+        }
+        for (const version of versions) {
+            const metadata = await loadMetadata(packageName, version);
+            if (!metadata) {
+                stdout.write(`⚠️  Skipping ${packageName}/${version}: no queriesMetadata found\n`);
+                continue;
+            }
+            const namespace = metadata.folderName || metadata.namespace;
+            const apis = metadata.services
+                .map((service) => service.apiClass)
+                .filter((apiClass) => apiClass && apiClass.length > 0);
+            if (apis.length > 0) {
+                result = {
+                    ...result,
+                    [namespace]: {
+                        packageName,
+                        apis,
+                    },
+                };
+            }
+        }
+    }
+    emitFiles({ res: result, sourceFolderGen: dir, sdkFactoryPath });
+    generateType(result);
+    exec('cd ../.. && pnpm run format').on('error', () => {
+        stdout.write('❌ Error during format !\n');
+        exit(1);
+    });
+    stdout.write('✅ files formatted !\n');
+};

package/dist/generateAPI/generateType.d.ts

@@ -1,2 +1,2 @@
-import type { ProcessDeclaration } from './types.ts';
-export declare const generateType: (res: ProcessDeclaration) => void;
+import type { ProcessedMetadata } from '../metadata-types.ts';
+export declare const generateType: (res: ProcessedMetadata) => void;

package/dist/generateAPI/generateType.js

@@ -6,15 +6,17 @@ export const generateType = (res) => {
     const template = ['//this file is generated \n\n'];
     // import types
     for (const [name, { packageName }] of Object.entries(res)) {
-        const imp = `import type { ${name} } from "${packageName}"\n`;
+        const capitalizedName = name.charAt(0).toUpperCase() + name.slice(1);
+        const imp = `import type { ${capitalizedName} } from "${packageName}"\n`;
         template.push(imp);
     }
     // export
     template.push('\n export type APISdk = {\n');
     for (const [name, { apis }] of Object.entries(res)) {
+        const capitalizedName = name.charAt(0).toUpperCase() + name.slice(1);
         for (const api of apis) {
             const key = `${lowerCaseFirstLetter(name + api.replace('API', ''))}`;
-            const type = `${name}.${api}`;
+            const type = `${capitalizedName}.${api}`;
             template.push(`${key}:${type},\n`);
         }
     }

package/dist/generateAPI/getFileContent.js

@@ -1,14 +1,15 @@
 import { lowerCaseFirstLetter } from './helpers.js';
 export const getFileContent = ({ packageName, name, api, sdkFactoryPath, }) => {
-    const apiName = name + api;
+    const capitalizedName = name.charAt(0).toUpperCase() + name.slice(1);
+    const apiName = capitalizedName + api;
     const keyValue = name + api.replace('API', '');
     const template = [
-        `import { ${name} } from "${packageName}"`,
+        `import { ${capitalizedName} } from "${packageName}"`,
         `import { createSDKFactory } from "${sdkFactoryPath}"`,
         '',
         '// This file is generated by scripts placed in `@scaleway/sdk:tools/generate-react-sdk` all modifications will be erased',
         `export const use${apiName} = createSDKFactory(`,
-        `${name}.${api},`,
+        `${capitalizedName}.${api},`,
         `'${lowerCaseFirstLetter(keyValue)}'`,
         ')',
     ].join('\n');

package/dist/generateAPI/index.d.ts

@@ -1 +1 @@
-export { generateAPI } from './generate.ts';
+export { generateAPI } from './generate-metadata.ts';

package/dist/generateAPI/index.js

@@ -1 +1 @@
-export { generateAPI } from './generate.js';
+export { generateAPI } from './generate-metadata.js';

package/dist/metadata-types.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Types for metadata-based generation.
+ * These types mirror the structure of metadata.gen.ts files in each SDK package.
+ */
+/** A single API method from metadata */
+export interface MetadataMethod {
+    methodName: string;
+    protoName: string;
+    paramsType: string;
+    returnType: string;
+    isList: boolean;
+    paginationType?: 'offset' | 'cursor' | 'none';
+    pageParamKey?: string;
+    listItemType?: string;
+    isPrivate: boolean;
+    description?: string;
+    hasWaiter?: boolean;
+}
+/** A service class (e.g. "API", "ZonedAPI") from metadata */
+export interface MetadataService {
+    apiClass: string;
+    methods: MetadataMethod[];
+}
+/** Top-level metadata from metadata.gen.ts */
+export interface Metadata {
+    namespace: string;
+    version: string;
+    folderName: string;
+    services: MetadataService[];
+}
+/** Processed result for code generation */
+export type ProcessedMetadata = {
+    [namespace: string]: {
+        packageName: string;
+        apis: string[];
+    };
+};

package/dist/metadata-types.js

@@ -0,0 +1,5 @@
+/**
+ * Types for metadata-based generation.
+ * These types mirror the structure of metadata.gen.ts files in each SDK package.
+ */
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scaleway/generate-react-sdk",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "generate react sdk",
   "type": "module",
   "private": false,
@@ -24,8 +24,7 @@
     "directory": "tools/generate-react-sdk"
   },
   "devDependencies": {
-    "@types/node": "20.19.35",
-    "ts-morph": "27.0.2"
+    "@types/node": "20.19.35"
   },
   "scripts": {
     "build": "tsgo -p tsconfig.build.json",

package/dist/generateAPI/config.d.ts

@@ -1,3 +0,0 @@
-import { Project } from 'ts-morph';
-export declare const project: Project;
-export declare const rawStringTypes: string[];

package/dist/generateAPI/config.js

@@ -1,5 +0,0 @@
-import { Project } from 'ts-morph';
-// Load the entry file
-export const project = new Project();
-// We dont want these types to be suffixed by namespaces
-export const rawStringTypes = ['string', 'Blob', 'string[]'];

package/dist/generateAPI/generate.js

@@ -1,57 +0,0 @@
-import { exec } from 'node:child_process';
-import { existsSync, readFileSync, rmSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { exit, stdout } from 'node:process';
-import { project } from './config.js';
-import { emitFiles } from './emitFiles.js';
-import { generateType } from './generateType.js';
-import { processDeclarationFile } from './processDeclarationFile.js';
-export const directoryOfSrcFolder = join(resolve('./'));
-// Read package.json
-const packageJson = JSON.parse(readFileSync(resolve(resolve('./'), 'package.json'), 'utf8'));
-export const generateAPI = ({ dirGenName, sdkFactoryPath, packageNameFilter, }) => {
-    let result = {};
-    const dir = join(directoryOfSrcFolder, dirGenName);
-    if (existsSync(dir)) {
-        rmSync(dir, {
-            recursive: true,
-            force: true,
-        });
-    }
-    // Generate SDK paths from dependencies
-    const sdkPaths = [
-        ...Object.keys(packageJson.dependencies ?? {}),
-        ...Object.keys(packageJson.devDependencies ?? {}),
-        ...Object.keys(packageJson.peerDependencies ?? {}),
-    ]
-        .filter(dep => dep.startsWith(packageNameFilter))
-        .filter(dep => !['@scaleway/sdk-client'].includes(dep))
-        .map(dep => {
-        const declarationFile = 'dist/index.gen.d.ts';
-        return [
-            dep,
-            resolve(resolve('./'), `./node_modules/${dep}/${declarationFile}`),
-        ];
-    });
-    for (const [packageName, sdkPath] of sdkPaths) {
-        if (!(packageName && sdkPath)) {
-            throw new Error('packageName or sdkPath is undefined');
-        }
-        const path = project.addSourceFileAtPath(sdkPath);
-        const res = processDeclarationFile({
-            namespace: '',
-            packageName,
-            result,
-            sourceFile: path,
-        });
-        result = { ...result, ...res };
-    }
-    emitFiles({ res: result, sourceFolderGen: dir, sdkFactoryPath });
-    generateType(result);
-    // // Finally we format all files to prevent updated files just because format is different
-    exec('cd ../.. && pnpm run format').on('error', () => {
-        stdout.write('❌ Error during format !\n');
-        exit(1);
-    });
-    stdout.write('✅ files formatted !\n');
-};

package/dist/generateAPI/processDeclarationFile.d.ts

@@ -1,2 +0,0 @@
-import type { ProcessDeclaration, ProcessDeclarationFileProps } from './types.ts';
-export declare function processDeclarationFile({ sourceFile, namespace, result, packageName }: ProcessDeclarationFileProps): ProcessDeclaration;

package/dist/generateAPI/processDeclarationFile.js

@@ -1,73 +0,0 @@
-import { resolveModule } from './resolveModule.js';
-// Recursive function to dive in all files
-export function processDeclarationFile({ sourceFile, namespace, result, packageName, }) {
-    let copyOfResult = { ...result };
-    // Export processing
-    for (const exportDecl of sourceFile.getExportDeclarations()) {
-        const moduleSpecifier = exportDecl.getModuleSpecifierValue();
-        if (!moduleSpecifier) {
-            break;
-        }
-        const resolvedFile = resolveModule(sourceFile, moduleSpecifier);
-        if (!resolvedFile) {
-            break;
-        }
-        copyOfResult = {
-            ...copyOfResult,
-            ...processDeclarationFile({
-                namespace: `${namespace}_${exportDecl.getNamespaceExport()?.getName() ?? ''}`,
-                packageName,
-                result: copyOfResult,
-                sourceFile: resolvedFile,
-            }),
-        };
-    }
-    // Import processing
-    for (const importDecl of sourceFile.getImportDeclarations()) {
-        const moduleSpecifier = importDecl.getModuleSpecifierValue();
-        if (!moduleSpecifier) {
-            break;
-        }
-        const resolvedFile = resolveModule(sourceFile, moduleSpecifier);
-        if (!resolvedFile) {
-            break;
-        }
-        // const newNS = `${namespace}_${importDecl.getNamespaceImport()?.getText() ?? ''}`
-        copyOfResult = {
-            ...copyOfResult,
-            ...processDeclarationFile({
-                namespace,
-                packageName,
-                result: copyOfResult,
-                sourceFile: resolvedFile,
-            }),
-        };
-    }
-    for (const classDecl of sourceFile.getClasses()) {
-        let className = classDecl.getName();
-        if (className === 'InstanceV1UtilsAPI') {
-            // instanceAPI is not well exported
-            className = 'API';
-        }
-        if (className &&
-            // theses API are manually set inside the SDK himself ...
-            !['K8SUtilsAPI', 'InstanceV1UtilsAPI'].includes(className)) {
-            const prettyNamespace = namespace.split('_').filter(aNamespace => aNamespace.length > 0)[0] ??
-                '';
-            // Take what ends with `API` and is not part of the ignored APIs array.
-            const namespaceApi = {
-                [prettyNamespace]: {
-                    apis: [
-                        ...new Set([
-                            ...(copyOfResult[prettyNamespace]?.apis ?? []),
-                            className,
-                        ]),
-                    ],
-                    packageName,
-                },
-            };
-            Object.assign(copyOfResult, namespaceApi);
-        }
-    }
-    return copyOfResult;
-}

package/dist/generateAPI/resolveModule.d.ts

@@ -1,2 +0,0 @@
-import type { SourceFile } from 'ts-morph';
-export declare function resolveModule(sourceFile: SourceFile, moduleSpecifier: string): SourceFile | null;

package/dist/generateAPI/resolveModule.js

@@ -1,25 +0,0 @@
-import { existsSync } from 'node:fs';
-import { dirname, resolve } from 'node:path/posix';
-// Resolve the referenced file in import/export
-export function resolveModule(sourceFile, moduleSpecifier) {
-    const currentDir = dirname(sourceFile.getFilePath());
-    let resolvedPath = resolve(currentDir, moduleSpecifier.replace('.js', ''));
-    // Ajouter les extensions .ts ou .d.ts si pas presente dans le path
-    if (!(resolvedPath.endsWith('.ts') || resolvedPath.endsWith('.d.ts'))) {
-        if (existsSync(`${resolvedPath}.ts`)) {
-            resolvedPath = `${resolvedPath}.ts`;
-        }
-        else if (existsSync(`${resolvedPath}.d.ts`)) {
-            resolvedPath = `${resolvedPath}.d.ts`;
-        }
-        else {
-            return null;
-        }
-    }
-    try {
-        return (sourceFile.getProject().addSourceFileAtPathIfExists(resolvedPath) ?? null);
-    }
-    catch {
-        return null;
-    }
-}

package/dist/generateAPI/types.d.ts

@@ -1,13 +0,0 @@
-import type { SourceFile } from 'ts-morph';
-export type ProcessDeclarationFileProps = {
-    sourceFile: SourceFile;
-    namespace: string;
-    result: ProcessDeclaration;
-    packageName: string;
-};
-export type ProcessDeclaration = {
-    [x: string]: {
-        packageName: string;
-        apis: string[];
-    };
-};

package/dist/generateAPI/types.js

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