@rimori/client 2.4.0 → 2.5.0-next.1

package/src/cli/scripts/release/release-config-upload.ts

@@ -1,119 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import ts from 'typescript';
-import { Config } from './release.js';
-import { detectTranslationLanguages } from './detect-translation-languages.js';
-
-/**
- * Read and send the rimori configuration to the release endpoint
- * @param config - Configuration object
- */
-export async function sendConfiguration(config: Config): Promise<string> {
-  const configPath = path.resolve('./rimori/rimori.config.ts');
-
-  // Check if config file exists
-  try {
-    await fs.promises.access(configPath);
-  } catch (e) {
-    throw new Error('Could not find rimori.config.ts in ./rimori/ directory');
-  }
-
-  try {
-    let configObject;
-
-    // Use TypeScript compiler to transpile and load
-    const configContent = await fs.promises.readFile(configPath, 'utf8');
-
-    // Transpile TypeScript to JavaScript
-    const result = ts.transpile(configContent, {
-      target: ts.ScriptTarget.ES2020,
-      module: ts.ModuleKind.ES2020,
-    });
-
-    // Create a temporary file to import the transpiled code
-    const tempFile = path.join(process.cwd(), 'temp_config.js');
-    await fs.promises.writeFile(tempFile, result);
-
-    try {
-      // Use dynamic import to load the config
-      const config = await import(`file://${tempFile}`);
-      configObject = config.default || config;
-
-      // Clean up temp file
-      await fs.promises.unlink(tempFile);
-    } catch (error) {
-      // Clean up temp file even on error
-      try {
-        await fs.promises.unlink(tempFile);
-      } catch (e) {}
-      throw error;
-    }
-
-    if (!configObject) {
-      throw new Error('Configuration object is empty or undefined');
-    }
-
-    // Detect available translation languages
-    const availableLanguages = await detectTranslationLanguages();
-
-    console.log(`🚀 Sending configuration...`);
-
-    const requestBody = {
-      config: configObject,
-      version: config.version,
-      plugin_id: config.plugin_id,
-      release_channel: config.release_channel,
-      rimori_client_version: config.rimori_client_version,
-      provided_languages: availableLanguages.join(','),
-    };
-
-    try {
-      const response = await fetch(`${config.domain}/release`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          Authorization: `Bearer ${config.token}`,
-        },
-        body: JSON.stringify(requestBody),
-      });
-
-      const responseText = await response.text();
-      console.log('Configuration response status:', response.status);
-      console.log('Configuration response text:', responseText);
-
-      const responseData = JSON.parse(responseText);
-      if (response.ok) {
-        console.log('✅ Configuration deployed successfully!');
-        return responseData.release_id;
-      } else {
-        console.log('❌ Configuration failed!');
-        console.log('Error:', responseData.error || 'Unknown error');
-        console.log('Response data:', JSON.stringify(responseData, null, 2));
-        throw new Error('Configuration upload failed');
-      }
-    } catch (e) {
-      console.log('error', e);
-      throw new Error('Error sending configuration');
-    }
-  } catch (error: any) {
-    console.error('❌ Error sending configuration:', error.message);
-    throw error;
-  }
-}
-
-export async function releasePlugin(config: Config, release_id: string): Promise<void> {
-  const response = await fetch(`${config.domain}/release/${release_id}/release`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      Authorization: `Bearer ${config.token}`,
-    },
-    body: JSON.stringify({ plugin_id: config.plugin_id }),
-  });
-
-  if (!response.ok) {
-    console.log('Response:', await response.text());
-    throw new Error('Failed to release plugin');
-  }
-  console.log('✅ Plugin released successfully');
-}

package/src/cli/scripts/release/release-db-update.ts

@@ -1,97 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import ts from 'typescript';
-import { Config } from './release';
-
-/**
- * Read and send the database configuration to the release endpoint
- * @param config - Configuration object
- */
-export default async function dbUpdate(config: Config, release_id: string): Promise<void> {
-  const dbConfigPath = path.resolve('./rimori/db.config.ts');
-
-  // Check if db config file exists
-  try {
-    await fs.promises.access(dbConfigPath);
-  } catch (e) {
-    console.warn('Could not find db.config.ts in ./rimori/ directory. Skipping database configuration upload.');
-    return;
-  }
-
-  try {
-    let dbConfigObject;
-
-    // Use TypeScript compiler to transpile and load
-    const dbConfigContent = await fs.promises.readFile(dbConfigPath, 'utf8');
-
-    // Transpile TypeScript to JavaScript
-    const result = ts.transpile(dbConfigContent, {
-      target: ts.ScriptTarget.ES2020,
-      module: ts.ModuleKind.ES2020,
-    });
-
-    // Create a temporary file to import the transpiled code
-    const tempFile = path.join(process.cwd(), 'temp_db_config.js');
-    await fs.promises.writeFile(tempFile, result);
-
-    try {
-      // Use dynamic import to load the db config
-      const dbConfig = await import(`file://${tempFile}`);
-      dbConfigObject = Object.values(dbConfig);
-
-      // Clean up temp file
-      await fs.promises.unlink(tempFile);
-    } catch (error) {
-      // Clean up temp file even on error
-      try {
-        await fs.promises.unlink(tempFile);
-      } catch (e) {}
-      throw error;
-    }
-
-    if (!dbConfigObject) {
-      throw new Error('Database configuration object is empty or undefined');
-    }
-
-    console.log(`🗄️ Sending database configuration...`);
-
-    const requestBody = {
-      db_config: dbConfigObject,
-      version: config.version,
-      release_channel: config.release_channel,
-      plugin_id: config.plugin_id,
-    };
-
-    const response = await fetch(`${config.domain}/release/${release_id}/db`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${config.token}`,
-      },
-      body: JSON.stringify(requestBody),
-    }).catch((e) => {
-      console.log('error', e);
-      throw new Error('Error sending database configuration');
-    });
-    try {
-      const responseText = await response.text().catch((e) => {
-        console.log('error', e);
-        throw new Error('Error sending database configuration');
-      });
-
-      const responseData = JSON.parse(responseText);
-      if (response.ok) {
-        console.log('✅ Database configuration deployed successfully!');
-      } else {
-        console.log('responseData', responseData);
-        throw new Error(responseData.message);
-      }
-    } catch (e) {
-      console.log('error', e);
-      throw new Error('Error sending database configuration');
-    }
-  } catch (error: any) {
-    console.error('❌ Error sending database configuration:', error.message);
-    throw error;
-  }
-}

package/src/cli/scripts/release/release-file-upload.ts

@@ -1,138 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { Config } from './release.js';
-
-/**
- * Upload all files from a directory and its subdirectories to the release function
- * @param config - Configuration object
- */
-export async function uploadDirectory(config: Config, release_id: string): Promise<void> {
-  const relativePath = './dist';
-
-  console.log(`📁 Preparing to upload files from ${relativePath}...`);
-
-  // Check if dist directory exists
-  try {
-    await fs.promises.access(relativePath);
-  } catch (e) {
-    throw new Error(`Directory ${relativePath} does not exist. Make sure to build your plugin first.`);
-  }
-  // Get all files recursively
-  const files = await getAllFiles(relativePath);
-
-  if (files.length === 0) {
-    console.log('⚠️ No files found to upload');
-    return;
-  }
-
-  console.log(`🚀 Uploading ${files.length} files...`);
-
-  // Create FormData
-  const formData = new FormData();
-
-  // Add version and release channel data
-  formData.append('version', config.version);
-  formData.append('release_channel', config.release_channel);
-  formData.append('plugin_id', config.plugin_id);
-
-  // Create path mapping with IDs as keys
-  const pathMapping: Record<string, string> = {};
-
-  for (let i = 0; i < files.length; i++) {
-    const filePath = files[i];
-    try {
-      const fileContent = await fs.promises.readFile(filePath);
-      const relativePath = path.relative('./dist', filePath);
-      const contentType = getContentType(filePath);
-
-      // Generate unique ID for this file
-      const fileId = `file_${i}`;
-
-      // Add to path mapping using ID as key
-      pathMapping[fileId] = relativePath;
-
-      // Create a Blob with the file content and content type
-      const blob = new Blob([new Uint8Array(fileContent)], { type: contentType });
-
-      // Add file to FormData with ID_filename format
-      const fileName = `${fileId}_${path.basename(filePath)}`;
-      formData.append('files', blob, fileName);
-    } catch (error: any) {
-      console.error(`❌ Error reading file ${filePath}:`, error.message);
-      throw error;
-    }
-  }
-
-  // Add path mapping to FormData
-  formData.append('path_mapping', JSON.stringify(pathMapping));
-
-  // Upload to the release endpoint
-  const response = await fetch(`${config.domain}/release/${release_id}/files`, {
-    method: 'POST',
-    headers: { Authorization: `Bearer ${config.token}` },
-    body: formData,
-  });
-
-  if (response.ok) {
-    console.log('✅ Files uploaded successfully!');
-  } else {
-    const errorText = await response.text();
-    console.log('❌ File upload failed!');
-    console.log('Response:', errorText);
-    throw new Error(`File upload failed with status ${response.status}`);
-  }
-}
-
-/**
- * Recursively get all files from a directory
- */
-async function getAllFiles(dirPath: string): Promise<string[]> {
-  const files: string[] = [];
-
-  async function traverse(currentPath: string) {
-    const entries = await fs.promises.readdir(currentPath, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const fullPath = path.join(currentPath, entry.name);
-
-      if (entry.isDirectory()) {
-        await traverse(fullPath);
-      } else if (entry.isFile()) {
-        files.push(fullPath);
-      }
-    }
-  }
-
-  await traverse(dirPath);
-  return files;
-}
-
-/**
- * Get content type based on file extension
- */
-function getContentType(filePath: string): string {
-  const ext = filePath.split('.').pop()?.toLowerCase();
-  const contentTypes: Record<string, string> = {
-    html: 'text/html',
-    css: 'text/css',
-    js: 'application/javascript',
-    json: 'application/json',
-    md: 'text/markdown',
-    txt: 'text/plain',
-    png: 'image/png',
-    jpg: 'image/jpeg',
-    jpeg: 'image/jpeg',
-    gif: 'image/gif',
-    svg: 'image/svg+xml',
-    pdf: 'application/pdf',
-    ico: 'image/x-icon',
-    mp3: 'audio/mpeg',
-    wav: 'audio/wav',
-    ogg: 'audio/ogg',
-    m4a: 'audio/mp4',
-    webp: 'image/webp',
-  };
-  const contentType = contentTypes[ext || ''];
-  if (!contentType) throw new Error(`Unsupported file type: ${ext}`);
-  return contentType;
-}

package/src/cli/scripts/release/release.ts

@@ -1,85 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Usage:
- *   rimori-release <release_channel>
- *
- * Environment variables required:
- *   RIMORI_TOKEN   - Your Rimori token
- *   RIMORI_PLUGIN  - Your plugin ID
- *
- * Make sure to install dependencies:
- *   npm install node-fetch form-data ts-node typescript
- */
-
-import 'dotenv/config';
-import fs from 'fs';
-import path from 'path';
-import dbUpdate from './release-db-update.js';
-import { uploadDirectory } from './release-file-upload.js';
-import { releasePlugin, sendConfiguration } from './release-config-upload.js';
-
-// Read version from package.json
-const packageJson = JSON.parse(fs.readFileSync(path.resolve('./package.json'), 'utf8'));
-const { version, r_id: pluginId } = packageJson;
-const RIMORI_TOKEN = process.env.RIMORI_TOKEN;
-
-if (!RIMORI_TOKEN) {
-  console.error('Error: RIMORI_TOKEN is not set');
-  process.exit(1);
-}
-if (!pluginId) {
-  console.error('Error: The plugin id (r_id) is not set in package.json');
-  process.exit(1);
-}
-
-const [releaseChannel] = process.argv.slice(2);
-if (!releaseChannel) {
-  console.error('Usage: rimori-release <release_channel>');
-  process.exit(1);
-}
-
-if (process.env.RIMORI_BACKEND_URL) {
-  console.info('Using backend url:', process.env.RIMORI_BACKEND_URL);
-}
-
-const config = {
-  version,
-  release_channel: releaseChannel,
-  plugin_id: pluginId,
-  token: RIMORI_TOKEN,
-  domain: process.env.RIMORI_BACKEND_URL || 'https://api.rimori.se',
-  rimori_client_version: packageJson.dependencies['@rimori/client'].replace('^', ''),
-};
-
-export type Config = typeof config;
-
-/**
- * Main release process
- */
-async function releaseProcess(): Promise<void> {
-  try {
-    console.log(`🚀 Releasing ${config.plugin_id} to ${config.release_channel}...`);
-
-    // First send the configuration
-    const release_id = await sendConfiguration(config);
-
-    await dbUpdate(config, release_id);
-
-    // Then upload the files
-    await uploadDirectory(config, release_id);
-
-    // Then release the plugin
-    await releasePlugin(config, release_id);
-
-    // Inform user about translation processing
-    console.log(
-      '🌐 Hint: The plugin is released but it might take some time until all translations are being processed.',
-    );
-  } catch (error: any) {
-    console.log('❌ Error:', error.message);
-    process.exit(1);
-  }
-}
-
-releaseProcess();

package/src/cli/types/DatabaseTypes.ts

@@ -1,125 +0,0 @@
-// Database table structure definitions
-
-/**
- * Supported database column data types for table schema definitions.
- */
-type DbColumnType = 'decimal' | 'integer' | 'text' | 'boolean' | 'json' | 'timestamp' | 'uuid';
-
-/**
- * Foreign key relationship configuration with cascade delete support.
- * Defines a relationship where the source record is deleted when the destination record is deleted.
- */
-interface ForeignKeyRelation {
-  /** The target table that this column references */
-  references_table: string;
-  /** The target column in the referenced table (defaults to 'id') */
-  references_column?: string;
-  /** Whether to cascade delete when the referenced record is deleted */
-  on_delete_cascade: boolean;
-}
-
-/**
- * Database column definition with support for types, constraints, and relationships.
- */
-export interface DbColumnDefinition {
-  /** The data type of the column */
-  type: DbColumnType;
-  /** Human-readable description of the column's purpose */
-  description: string;
-  /** Whether the column can contain null values */
-  nullable?: boolean;
-  /** Whether the column has a unique constraint */
-  unique?: boolean;
-  /** Default value for the column. can also use sql functions like now(), auth.uid() or gen_random_uuid() */
-  default_value?: string | number | boolean;
-  /** Array of allowed values for enumerated columns */
-  // enum?: string[];
-  /** Foreign key relationship configuration */
-  foreign_key?: ForeignKeyRelation;
-  /** The name of the column before it was renamed. */
-  old_name?: string;
-  /** Whether the column is deprecated. The column gets renamed to column_name_old. To fully remove the column, first set deprecated to true and then after a release, remove the column from the table definition. */
-  deprecated?: boolean;
-  /** Whether the column is a primary key */
-  // primary_key?: boolean;
-  /** Restrictions for the column. If the column is restricted, the permission is further restricted. E.g. if the column is restricted to user, then the user can only read the column if they have the right permission.
-   * Example: Denying users to update the column, but allowing the moderator to update the column.
-   */
-  restrict?: {
-    /** Restrictions for the user */
-    user: Partial<Omit<DbPermissionDefinition, 'delete'>>;
-    /** Restrictions for the guild moderator */
-    guild_moderator?: Partial<Omit<DbPermissionDefinition, 'delete'>>;
-    /** Restrictions for the language moderator */
-    lang_moderator?: Partial<Omit<DbPermissionDefinition, 'delete'>>;
-    /** Restrictions for the maintainer */
-    // maintainer?: Partial<Omit<DbPermissionDefinition, 'delete'>>;
-  };
-}
-
-/**
- * Base table structure that all database tables inherit.
- * Includes standard audit fields for tracking creation and ownership.
- */
-interface BaseTableStructure {
-  /** Unique identifier for the record */
-  id: DbColumnDefinition;
-  /** Timestamp when the record was created */
-  created_at: DbColumnDefinition;
-  /** ID of the user who created the record */
-  created_by: DbColumnDefinition;
-}
-
-/**
- * Complete database table schema definition.
- * Defines the structure, constraints, and relationships for a database table.
- */
-export interface DbTableDefinition {
-  /** Name of the database table */
-  table_name: string;
-  /** Description of the table's purpose and usage */
-  description: string;
-  /** Permissions for the table */
-  permissions: {
-    /** Permissions for the user */
-    user: DbPermissionDefinition;
-    /** Permissions for the guild moderator */
-    guild_moderator?: DbPermissionDefinition;
-    /** Permissions for the language moderator */
-    lang_moderator?: DbPermissionDefinition;
-    /** Permissions for the maintainer */
-    // maintainer?: DbPermissionDefinition;
-  };
-  /** Column definitions for the table */
-  columns: {
-    [column_name: string]: DbColumnDefinition;
-  };
-}
-
-/**
- * Permission definition for a database table.
- * NONE means the action is not allowed.
- * OWN means only do the action on your own records.
- * GUILD means do the action on all records in the guild.
- * LANG means do the action on all records in the language.
- * ALL means do the action on all records.
- *
- * Defines the permissions for a database table.
- */
-export type DbPermission = 'NONE' | 'OWN' | 'GUILD' | 'LANG' | 'ALL';
-
-/**
- * Permission definition for a database table.
- * Defines the permissions for a database table.
- */
-export interface DbPermissionDefinition {
-  read: DbPermission;
-  insert: DbPermission;
-  update: DbPermission;
-  delete: DbPermission;
-}
-
-/**
- * Full table definition that includes automatically generated fields.
- */
-export type FullTable<T extends Record<string, DbColumnDefinition>> = T & BaseTableStructure;