appwrite-utils-cli 1.9.7 → 1.12.0

package/dist/functions/pathResolution.d.ts

@@ -1,37 +0,0 @@
-/**
- * Expands tilde (~) in paths to the user's home directory
- * @param pathStr - Path string that may contain ~
- * @returns Expanded path with home directory
- */
-export declare function expandTildePath(pathStr: string): string;
-/**
- * Normalizes function name to standard format (lowercase, dashes instead of spaces)
- * @param name - Function name to normalize
- * @returns Normalized function name
- */
-export declare function normalizeFunctionName(name: string): string;
-/**
- * Validates that a directory exists and contains function markers
- * @param dirPath - Directory path to validate
- * @returns True if directory is a valid function directory
- */
-export declare function validateFunctionDirectory(dirPath: string): boolean;
-/**
- * Helper function to search for function in standard locations
- * @param configDirPath - Directory where config file is located
- * @param normalizedName - Normalized function name
- * @returns First valid function directory path or undefined
- */
-export declare function findFunctionInStandardLocations(configDirPath: string, normalizedName: string): string | undefined;
-/**
- * Resolves the absolute path to a function directory
- * Handles multiple resolution strategies with proper priority
- *
- * @param functionName - Name of the function
- * @param configDirPath - Directory where config file is located
- * @param dirPath - Optional explicit dirPath from config
- * @param explicitPath - Optional path passed as parameter (highest priority)
- * @returns Absolute path to the function directory
- * @throws Error if function directory cannot be found or is invalid
- */
-export declare function resolveFunctionDirectory(functionName: string, configDirPath: string, dirPath?: string, explicitPath?: string): string;

package/dist/functions/pathResolution.js

@@ -1,185 +0,0 @@
-import { existsSync, statSync, readdirSync } from 'node:fs';
-import { join, resolve, isAbsolute } from 'node:path';
-import { homedir } from 'node:os';
-import { MessageFormatter } from '../shared/messageFormatter.js';
-import { logger } from '../shared/logging.js';
-/**
- * Expands tilde (~) in paths to the user's home directory
- * @param pathStr - Path string that may contain ~
- * @returns Expanded path with home directory
- */
-export function expandTildePath(pathStr) {
-    if (!pathStr)
-        return pathStr;
-    if (pathStr.startsWith('~/') || pathStr === '~') {
-        const expandedPath = pathStr.replace(/^~(?=$|\/|\\)/, homedir());
-        logger.debug('Expanded tilde path', { original: pathStr, expanded: expandedPath });
-        return expandedPath;
-    }
-    return pathStr;
-}
-/**
- * Normalizes function name to standard format (lowercase, dashes instead of spaces)
- * @param name - Function name to normalize
- * @returns Normalized function name
- */
-export function normalizeFunctionName(name) {
-    if (!name)
-        return name;
-    const normalized = name.toLowerCase().replace(/\s+/g, '-');
-    if (normalized !== name) {
-        logger.debug('Normalized function name', { original: name, normalized });
-    }
-    return normalized;
-}
-/**
- * Validates that a directory exists and contains function markers
- * @param dirPath - Directory path to validate
- * @returns True if directory is a valid function directory
- */
-export function validateFunctionDirectory(dirPath) {
-    try {
-        // Check if directory exists
-        if (!existsSync(dirPath)) {
-            logger.debug('Directory does not exist', { dirPath });
-            return false;
-        }
-        // Check if it's actually a directory
-        const stats = statSync(dirPath);
-        if (!stats.isDirectory()) {
-            logger.debug('Path is not a directory', { dirPath });
-            return false;
-        }
-        // Check for function markers
-        const contents = readdirSync(dirPath);
-        const hasPackageJson = contents.includes('package.json');
-        const hasPyprojectToml = contents.includes('pyproject.toml');
-        const hasSrcDir = contents.includes('src');
-        const isValid = hasPackageJson || hasPyprojectToml || hasSrcDir;
-        logger.debug('Function directory validation', {
-            dirPath,
-            isValid,
-            markers: {
-                hasPackageJson,
-                hasPyprojectToml,
-                hasSrcDir
-            }
-        });
-        return isValid;
-    }
-    catch (error) {
-        logger.debug('Error validating function directory', {
-            dirPath,
-            error: error instanceof Error ? error.message : String(error)
-        });
-        return false;
-    }
-}
-/**
- * Helper function to search for function in standard locations
- * @param configDirPath - Directory where config file is located
- * @param normalizedName - Normalized function name
- * @returns First valid function directory path or undefined
- */
-export function findFunctionInStandardLocations(configDirPath, normalizedName) {
-    const searchPaths = [
-        // Same directory as config
-        join(configDirPath, 'functions', normalizedName),
-        // Parent directory of config
-        join(configDirPath, '..', 'functions', normalizedName),
-        // Current working directory
-        join(process.cwd(), 'functions', normalizedName),
-    ];
-    logger.debug('Searching for function in standard locations', {
-        normalizedName,
-        configDirPath,
-        searchPaths
-    });
-    for (const searchPath of searchPaths) {
-        const resolvedPath = resolve(searchPath);
-        logger.debug('Checking search path', { searchPath, resolvedPath });
-        if (validateFunctionDirectory(resolvedPath)) {
-            logger.debug('Found function in standard location', { resolvedPath });
-            return resolvedPath;
-        }
-    }
-    logger.debug('Function not found in any standard location', { normalizedName });
-    return undefined;
-}
-/**
- * Resolves the absolute path to a function directory
- * Handles multiple resolution strategies with proper priority
- *
- * @param functionName - Name of the function
- * @param configDirPath - Directory where config file is located
- * @param dirPath - Optional explicit dirPath from config
- * @param explicitPath - Optional path passed as parameter (highest priority)
- * @returns Absolute path to the function directory
- * @throws Error if function directory cannot be found or is invalid
- */
-export function resolveFunctionDirectory(functionName, configDirPath, dirPath, explicitPath) {
-    logger.debug('Resolving function directory', {
-        functionName,
-        configDirPath,
-        dirPath,
-        explicitPath
-    });
-    const normalizedName = normalizeFunctionName(functionName);
-    // Priority 1: Explicit path parameter (highest priority)
-    if (explicitPath) {
-        logger.debug('Using explicit path parameter');
-        const expandedPath = expandTildePath(explicitPath);
-        const resolvedPath = isAbsolute(expandedPath)
-            ? expandedPath
-            : resolve(process.cwd(), expandedPath);
-        if (!validateFunctionDirectory(resolvedPath)) {
-            const errorMsg = `Explicit path is not a valid function directory: ${resolvedPath}`;
-            logger.error(errorMsg);
-            MessageFormatter.error('Invalid function directory', errorMsg, { prefix: 'Path Resolution' });
-            throw new Error(errorMsg);
-        }
-        logger.debug('Resolved using explicit path', { resolvedPath });
-        MessageFormatter.debug(`Resolved function directory using explicit path: ${resolvedPath}`, undefined, { prefix: 'Path Resolution' });
-        return resolvedPath;
-    }
-    // Priority 2: dirPath from config (relative to config location)
-    if (dirPath) {
-        logger.debug('Using dirPath from config');
-        const expandedPath = expandTildePath(dirPath);
-        const resolvedPath = isAbsolute(expandedPath)
-            ? expandedPath
-            : resolve(configDirPath, expandedPath);
-        if (!validateFunctionDirectory(resolvedPath)) {
-            const errorMsg = `Config dirPath is not a valid function directory: ${resolvedPath}`;
-            logger.error(errorMsg);
-            MessageFormatter.error('Invalid function directory', errorMsg, { prefix: 'Path Resolution' });
-            throw new Error(errorMsg);
-        }
-        logger.debug('Resolved using config dirPath', { resolvedPath });
-        MessageFormatter.debug(`Resolved function directory using config dirPath: ${resolvedPath}`, undefined, { prefix: 'Path Resolution' });
-        return resolvedPath;
-    }
-    // Priority 3: Search standard locations
-    logger.debug('Searching standard locations for function');
-    const foundPath = findFunctionInStandardLocations(configDirPath, normalizedName);
-    if (foundPath) {
-        logger.debug('Resolved using standard location search', { foundPath });
-        MessageFormatter.debug(`Found function directory in standard location: ${foundPath}`, undefined, { prefix: 'Path Resolution' });
-        return foundPath;
-    }
-    // Priority 4: Not found - throw error
-    const searchedLocations = [
-        join(configDirPath, 'functions', normalizedName),
-        join(configDirPath, '..', 'functions', normalizedName),
-        join(process.cwd(), 'functions', normalizedName),
-    ];
-    const errorMsg = `Function directory not found for '${functionName}' (normalized: '${normalizedName}'). ` +
-        `Searched locations:\n${searchedLocations.map(p => `  - ${p}`).join('\n')}`;
-    logger.error('Function directory not found', {
-        functionName,
-        normalizedName,
-        searchedLocations
-    });
-    MessageFormatter.error('Function directory not found', errorMsg, { prefix: 'Path Resolution' });
-    throw new Error(errorMsg);
-}

package/dist/functions/templates/count-docs-in-collection/package.json

@@ -1,25 +0,0 @@
-{
-  "name": "{{functionName}}",
-  "version": "1.0.0",
-  "description": "Appwrite function to count documents in a collection",
-  "main": "src/main.ts",
-  "type": "module",
-  "scripts": {
-    "build": "tsc",
-    "start": "node dist/main.js",
-    "dev": "tsx src/main.ts"
-  },
-  "dependencies": {
-    "node-appwrite": "^13.0.0",
-    "appwrite-utils": "latest",
-    "zod": "^3.23.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "typescript": "^5.0.0",
-    "tsx": "^4.0.0"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  }
-}

package/dist/functions/templates/count-docs-in-collection/tsconfig.json

@@ -1,28 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "node",
-    "allowSyntheticDefaultImports": true,
-    "esModuleInterop": true,
-    "allowJs": true,
-    "checkJs": false,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "noImplicitAny": true,
-    "strictNullChecks": true,
-    "strictFunctionTypes": true,
-    "noImplicitThis": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "moduleDetection": "force",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "verbatimModuleSyntax": false,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}

package/dist/functions/templates/hono-typescript/package.json

@@ -1,26 +0,0 @@
-{
-  "name": "{{functionName}}",
-  "version": "1.0.0",
-  "description": "Appwrite TypeScript function with Hono web framework",
-  "main": "src/index.ts",
-  "type": "module",
-  "scripts": {
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "dev": "tsx src/index.ts"
-  },
-  "dependencies": {
-    "node-appwrite": "^13.0.0",
-    "appwrite-utils": "latest",
-    "hono": "^4.0.0",
-    "zod": "^3.22.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "typescript": "^5.0.0",
-    "tsx": "^4.0.0"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  }
-}

package/dist/functions/templates/hono-typescript/src/index.ts

@@ -1,54 +0,0 @@
-import { app } from "./app.js";
-import { AppwriteContext, AppwriteContextSchema } from "./context.js";
-import { convertAppwriteToWebRequest } from "./adapters/request.js";
-import { convertWebResponseToAppwrite } from "./adapters/response.js";
-import { appwriteMiddleware } from "./middleware/appwrite.js";
-
-/**
- * Main Appwrite function entry point
- * This function receives the Appwrite context and routes it through Hono
- */
-export default async function (context: AppwriteContext) {
-  const { req, res, log, error } = context;
-
-  try {
-    // Optional: Validate the context using Zod schema
-    AppwriteContextSchema.parse(context);
-    log("Context validation successful");
-
-    // Add Appwrite context middleware to the Hono app
-    app.use("*", appwriteMiddleware(context));
-
-    // Convert Appwrite request to Web API Request for Hono
-    const webRequest = convertAppwriteToWebRequest(req);
-
-    log(`Processing ${req.method} request to ${req.path || "/"}`);
-
-    // Create execution environment for Hono
-    const env = {
-      // Add any environment variables or context needed by Hono
-      APPWRITE_FUNCTION_ENDPOINT: process.env["APPWRITE_FUNCTION_ENDPOINT"],
-      APPWRITE_FUNCTION_PROJECT_ID: process.env["APPWRITE_FUNCTION_PROJECT_ID"],
-      APPWRITE_FUNCTION_API_KEY: process.env["APPWRITE_FUNCTION_API_KEY"],
-    };
-
-    // Process request through Hono app
-    const honoResponse = await app.fetch(webRequest, env);
-
-    // Convert Hono response back to Appwrite response format
-    await convertWebResponseToAppwrite(honoResponse, res);
-
-    log(`Request completed with status ${honoResponse.status}`);
-
-  } catch (validationError) {
-    error(`Function execution failed: ${validationError}`);
-
-    // Return error response
-    return res.json({
-      error: "Function execution failed",
-      message: validationError instanceof Error ? validationError.message : String(validationError),
-      functionName: "{{functionName}}",
-      timestamp: new Date().toISOString(),
-    }, 500);
-  }
-}

package/dist/functions/templates/hono-typescript/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ES2022",
-    "moduleResolution": "node",
-    "allowSyntheticDefaultImports": true,
-    "esModuleInterop": true,
-    "allowJs": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "resolveJsonModule": true,
-    "types": ["node"]
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}

package/dist/functions/templates/typescript-node/package.json

@@ -1,25 +0,0 @@
-{
-  "name": "{{functionName}}",
-  "version": "1.0.0",
-  "description": "Appwrite TypeScript Node.js function",
-  "main": "src/index.ts",
-  "type": "module",
-  "scripts": {
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "dev": "tsx src/index.ts"
-  },
-  "dependencies": {
-    "node-appwrite": "^13.0.0",
-    "appwrite-utils": "latest",
-    "zod": "^3.22.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "typescript": "^5.0.0",
-    "tsx": "^4.0.0"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  }
-}

package/dist/functions/templates/typescript-node/tsconfig.json

@@ -1,28 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "node",
-    "allowSyntheticDefaultImports": true,
-    "esModuleInterop": true,
-    "allowJs": true,
-    "checkJs": false,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "noImplicitAny": true,
-    "strictNullChecks": true,
-    "strictFunctionTypes": true,
-    "noImplicitThis": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "moduleDetection": "force",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "verbatimModuleSyntax": false,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}

package/dist/shared/attributeMapper.d.ts

@@ -1,20 +0,0 @@
-import type { CreateAttributeParams, UpdateAttributeParams } from "../adapters/DatabaseAdapter.js";
-import type { Attribute } from "appwrite-utils";
-/**
- * Map a schema Attribute into DatabaseAdapter CreateAttributeParams
- * Only includes fields valid for the specific type to satisfy TS unions.
- * Also normalizes min/max ordering for numeric types to avoid server errors.
- */
-export declare function mapToCreateAttributeParams(attr: Attribute, base: {
-    databaseId: string;
-    tableId: string;
-}): CreateAttributeParams;
-/**
- * Map a schema Attribute into DatabaseAdapter UpdateAttributeParams
- * Omits fields that are not explicitly provided, and guards enum updates
- * so we never send an empty elements array (preserve existing on server).
- */
-export declare function mapToUpdateAttributeParams(attr: Attribute, base: {
-    databaseId: string;
-    tableId: string;
-}): UpdateAttributeParams;

package/dist/shared/attributeMapper.js

@@ -1,203 +0,0 @@
-function ensureNumber(n) {
-    if (n === null || n === undefined)
-        return undefined;
-    const num = Number(n);
-    return Number.isFinite(num) ? num : undefined;
-}
-/**
- * Map a schema Attribute into DatabaseAdapter CreateAttributeParams
- * Only includes fields valid for the specific type to satisfy TS unions.
- * Also normalizes min/max ordering for numeric types to avoid server errors.
- */
-export function mapToCreateAttributeParams(attr, base) {
-    const type = String(attr.type || "").toLowerCase();
-    const required = !!attr.required;
-    const array = !!attr.array;
-    const xdefault = attr.xdefault;
-    const encrypt = attr.encrypt;
-    // Numeric helpers
-    const rawMin = ensureNumber(attr.min);
-    const rawMax = ensureNumber(attr.max);
-    let min = rawMin;
-    let max = rawMax;
-    if (min !== undefined && max !== undefined && min >= max) {
-        // Swap to satisfy server-side validation
-        const tmp = min;
-        min = Math.min(min, max);
-        max = Math.max(tmp, max);
-        if (min === max) {
-            // If still equal, unset max to avoid error
-            max = undefined;
-        }
-    }
-    switch (type) {
-        case "string":
-            return {
-                databaseId: base.databaseId,
-                tableId: base.tableId,
-                key: attr.key,
-                type,
-                size: attr.size ?? 255,
-                required,
-                default: xdefault,
-                array,
-                encrypt: !!encrypt,
-            };
-        case "integer":
-            return {
-                databaseId: base.databaseId,
-                tableId: base.tableId,
-                key: attr.key,
-                type,
-                required,
-                default: xdefault,
-                array,
-                min,
-                max,
-            };
-        case "double":
-        case "float":
-            return {
-                databaseId: base.databaseId,
-                tableId: base.tableId,
-                key: attr.key,
-                type,
-                required,
-                default: xdefault,
-                array,
-                min,
-                max,
-            };
-        case "boolean":
-            return {
-                databaseId: base.databaseId,
-                tableId: base.tableId,
-                key: attr.key,
-                type,
-                required,
-                default: xdefault,
-                array,
-            };
-        case "datetime":
-        case "email":
-        case "ip":
-        case "url":
-            return {
-                databaseId: base.databaseId,
-                tableId: base.tableId,
-                key: attr.key,
-                type,
-                required,
-                default: xdefault,
-                array,
-            };
-        case "enum":
-            {
-                const elements = attr.elements;
-                if (!Array.isArray(elements) || elements.length === 0) {
-                    // Creating an enum without elements is invalid – fail fast with clear messaging
-                    throw new Error(`Enum attribute '${attr.key}' requires a non-empty 'elements' array for creation`);
-                }
-            }
-            return {
-                databaseId: base.databaseId,
-                tableId: base.tableId,
-                key: attr.key,
-                type,
-                required,
-                default: xdefault,
-                array,
-                elements: attr.elements,
-            };
-        case "relationship": {
-            // Relationship attributes require related collection and metadata
-            return {
-                databaseId: base.databaseId,
-                tableId: base.tableId,
-                key: attr.key,
-                type,
-                relatedCollection: attr.relatedCollection,
-                relationType: attr.relationType,
-                twoWay: attr.twoWay,
-                twoWayKey: attr.twoWayKey,
-                onDelete: attr.onDelete,
-                side: attr.side,
-            };
-        }
-        default:
-            return {
-                databaseId: base.databaseId,
-                tableId: base.tableId,
-                key: attr.key,
-                type,
-                required,
-            };
-    }
-}
-/**
- * Map a schema Attribute into DatabaseAdapter UpdateAttributeParams
- * Omits fields that are not explicitly provided, and guards enum updates
- * so we never send an empty elements array (preserve existing on server).
- */
-export function mapToUpdateAttributeParams(attr, base) {
-    const type = String((attr.type == 'string' && attr.format !== 'enum') || attr.type !== 'string' ? attr.type : 'enum').toLowerCase();
-    const params = {
-        databaseId: base.databaseId,
-        tableId: base.tableId,
-        key: attr.key,
-    };
-    const setIfDefined = (key, value) => {
-        if (value !== undefined)
-            params[key] = value;
-    };
-    // Common fields
-    setIfDefined("type", type);
-    setIfDefined("required", attr.required);
-    // Only send default if explicitly provided and not on required
-    if (!attr.required && attr.xdefault !== undefined) {
-        setIfDefined("default", attr.xdefault);
-    }
-    setIfDefined("array", attr.array);
-    // encrypt only applies to string types
-    if (type === "string")
-        setIfDefined("encrypt", attr.encrypt);
-    // Numeric normalization
-    const toNum = (n) => (n === null || n === undefined ? undefined : (Number(n)));
-    let min = toNum(attr.min);
-    let max = toNum(attr.max);
-    if (min !== undefined && max !== undefined && min >= max) {
-        const tmp = min;
-        min = Math.min(min, max);
-        max = Math.max(tmp, max);
-        if (min === max)
-            max = undefined;
-    }
-    switch (type) {
-        case "string":
-            setIfDefined("size", attr.size);
-            break;
-        case "integer":
-        case "float":
-        case "double":
-            setIfDefined("min", min);
-            setIfDefined("max", max);
-            break;
-        case "enum": {
-            const elements = attr.elements;
-            if (Array.isArray(elements) && elements.length > 0) {
-                // Only include when non-empty; otherwise preserve existing on server
-                setIfDefined("elements", elements);
-            }
-            break;
-        }
-        case "relationship": {
-            setIfDefined("relatedCollection", attr.relatedCollection);
-            setIfDefined("relationType", attr.relationType);
-            setIfDefined("twoWay", attr.twoWay);
-            setIfDefined("twoWayKey", attr.twoWayKey);
-            setIfDefined("onDelete", attr.onDelete);
-            break;
-        }
-    }
-    return params;
-}