appwrite-utils-cli 1.7.7 → 1.7.9

package/dist/utils/configDiscovery.js

@@ -135,6 +135,45 @@ const YamlCollectionSchema = z.object({
     })).optional().default([]),
     importDefs: z.array(z.any()).optional().default([])
 });
+// YAML Table Schema - Supports table-specific terminology
+const YamlTableSchema = z.object({
+    name: z.string(),
+    id: z.string().optional(),
+    rowSecurity: z.boolean().default(false), // Tables use rowSecurity
+    enabled: z.boolean().default(true),
+    permissions: z.array(z.object({
+        permission: z.string(),
+        target: z.string()
+    })).optional().default([]),
+    columns: z.array(// Tables use columns terminology
+    z.object({
+        key: z.string(),
+        type: z.string(),
+        size: z.number().optional(),
+        required: z.boolean().default(false),
+        array: z.boolean().optional(),
+        encrypted: z.boolean().optional(), // Tables support encrypted property
+        default: z.any().optional(),
+        min: z.number().optional(),
+        max: z.number().optional(),
+        elements: z.array(z.string()).optional(),
+        relatedTable: z.string().optional(), // Tables use relatedTable
+        relationType: z.string().optional(),
+        twoWay: z.boolean().optional(),
+        twoWayKey: z.string().optional(),
+        onDelete: z.string().optional(),
+        side: z.string().optional(),
+        encrypt: z.boolean().optional(),
+        format: z.string().optional()
+    })).optional().default([]),
+    indexes: z.array(z.object({
+        key: z.string(),
+        type: z.string(),
+        columns: z.array(z.string()), // Tables use columns in indexes
+        orders: z.array(z.string()).optional()
+    })).optional().default([]),
+    importDefs: z.array(z.any()).optional().default([])
+});
 /**
  * Loads a YAML collection file and converts it to CollectionCreate format
  * @param filePath Path to the YAML collection file
@@ -190,55 +229,52 @@ export const loadYamlCollection = (filePath) => {
     }
 };
 /**
- * Loads a YAML table file and converts it to table format
+ * Loads a YAML table file and converts it to CollectionCreate format
  * @param filePath Path to the YAML table file
- * @returns Table object or null if loading fails
+ * @returns CollectionCreate object or null if loading fails
  */
 export const loadYamlTable = (filePath) => {
     try {
         const fileContent = fs.readFileSync(filePath, "utf8");
         const yamlData = yaml.load(fileContent);
-        // For now, use the collection schema as base and adapt for tables
-        const parsedTable = YamlCollectionSchema.parse(yamlData);
-        // Convert YAML table to TableCreate format
+        // Use the new table-specific schema
+        const parsedTable = YamlTableSchema.parse(yamlData);
+        // Convert YAML table to CollectionCreate format (internal representation)
         const table = {
             name: parsedTable.name,
-            tableId: yamlData.tableId || parsedTable.id || parsedTable.name.toLowerCase().replace(/\s+/g, '_'),
-            documentSecurity: parsedTable.documentSecurity,
+            $id: yamlData.tableId || parsedTable.id || parsedTable.name.toLowerCase().replace(/\s+/g, '_'),
+            documentSecurity: parsedTable.rowSecurity, // Convert rowSecurity to documentSecurity
             enabled: parsedTable.enabled,
             $permissions: parsedTable.permissions.map(p => ({
                 permission: p.permission,
                 target: p.target
             })),
-            attributes: parsedTable.attributes.map(attr => ({
-                key: attr.key,
-                type: attr.type,
-                size: attr.size,
-                required: attr.required,
-                array: attr.array,
-                xdefault: attr.default,
-                min: attr.min,
-                max: attr.max,
-                elements: attr.elements,
-                relatedCollection: attr.relatedCollection,
-                relationType: attr.relationType,
-                twoWay: attr.twoWay,
-                twoWayKey: attr.twoWayKey,
-                onDelete: attr.onDelete,
-                side: attr.side,
-                encrypted: attr.encrypt,
-                format: attr.format
+            attributes: parsedTable.columns.map(col => ({
+                key: col.key,
+                type: col.type,
+                size: col.size,
+                required: col.required,
+                array: col.array,
+                xdefault: col.default,
+                min: col.min,
+                max: col.max,
+                elements: col.elements,
+                relatedCollection: col.relatedTable, // Convert relatedTable to relatedCollection
+                relationType: col.relationType,
+                twoWay: col.twoWay,
+                twoWayKey: col.twoWayKey,
+                onDelete: col.onDelete,
+                side: col.side,
+                encrypted: col.encrypted || col.encrypt, // Support both encrypted and encrypt
+                format: col.format
             })),
             indexes: parsedTable.indexes.map(idx => ({
                 key: idx.key,
                 type: idx.type,
-                attributes: idx.attributes,
+                attributes: idx.columns, // Convert columns to attributes
                 orders: idx.orders
             })),
-            importDefs: parsedTable.importDefs,
-            databaseId: yamlData.databaseId,
-            // Add backward compatibility field
-            $id: yamlData.$id || parsedTable.id
+            importDefs: parsedTable.importDefs || []
         };
         return table;
     }

package/dist/utils/yamlConverter.d.ts

@@ -3,6 +3,7 @@ export interface YamlCollectionData {
     name: string;
     id?: string;
     documentSecurity?: boolean;
+    rowSecurity?: boolean;
     enabled?: boolean;
     permissions?: Array<{
         permission: string;

package/dist/utils/yamlConverter.js

@@ -15,9 +15,15 @@ export function collectionToYaml(collection, config = {
     const yamlData = {
         name: collection.name,
         id: collection.$id,
-        documentSecurity: collection.documentSecurity,
         enabled: collection.enabled,
     };
+    // Use appropriate security field based on terminology
+    if (config.useTableTerminology) {
+        yamlData.rowSecurity = collection.documentSecurity;
+    }
+    else {
+        yamlData.documentSecurity = collection.documentSecurity;
+    }
     // Convert permissions
     if (collection.$permissions && collection.$permissions.length > 0) {
         yamlData.permissions = collection.$permissions.map(p => ({
@@ -158,6 +164,11 @@ export function normalizeYamlData(yamlData) {
             columns: undefined
         }));
     }
+    // Normalize security fields - prefer documentSecurity for consistency
+    if (yamlData.rowSecurity !== undefined && yamlData.documentSecurity === undefined) {
+        normalized.documentSecurity = yamlData.rowSecurity;
+        delete normalized.rowSecurity;
+    }
     return normalized;
 }
 /**
@@ -165,7 +176,8 @@ export function normalizeYamlData(yamlData) {
  */
 export function usesTableTerminology(yamlData) {
     return !!(yamlData.columns && yamlData.columns.length > 0) ||
-        !!(yamlData.indexes?.some(idx => !!idx.columns));
+        !!(yamlData.indexes?.some(idx => !!idx.columns)) ||
+        yamlData.rowSecurity !== undefined;
 }
 /**
  * Converts between attribute and column terminology
@@ -190,6 +202,11 @@ export function convertTerminology(yamlData, toTableTerminology) {
                 attributes: idx.attributes // Keep both for compatibility
             }));
         }
+        // Convert security field
+        if (yamlData.documentSecurity !== undefined && yamlData.rowSecurity === undefined) {
+            converted.rowSecurity = yamlData.documentSecurity;
+            delete converted.documentSecurity;
+        }
         return converted;
     }
     else {
@@ -272,7 +289,6 @@ export function generateYamlTemplate(entityName, config) {
     const template = {
         name: entityName,
         id: entityName.toLowerCase().replace(/\s+/g, '_'),
-        documentSecurity: false,
         enabled: true,
         permissions: [
             {
@@ -294,6 +310,13 @@ export function generateYamlTemplate(entityName, config) {
         ],
         importDefs: []
     };
+    // Use appropriate security field based on terminology
+    if (config.useTableTerminology) {
+        template.rowSecurity = false;
+    }
+    else {
+        template.documentSecurity = false;
+    }
     // Assign fields with correct property name
     template[fieldsKey] = fieldsArray;
     template.indexes = indexesArray;

package/dist/utilsController.d.ts

@@ -4,6 +4,7 @@ import { type AfterImportActions, type ConverterFunctions, type ValidationRules
 import { type TransferOptions } from "./migrations/transfer.js";
 import type { DatabaseAdapter } from './adapters/DatabaseAdapter.js';
 import { type ValidationResult } from "./config/configValidation.js";
+import type { DatabaseSelection, BucketSelection } from "./shared/selectionDialogs.js";
 export interface SetupOptions {
     databases?: Models.Database[];
     collections?: string[];
@@ -60,6 +61,9 @@ export declare class UtilsController {
     ensureDatabasesExist(databases?: Models.Database[]): Promise<void>;
     ensureCollectionsExist(database: Models.Database, collections?: Models.Collection[]): Promise<void>;
     getDatabasesByIds(ids: string[]): Promise<Models.Database[] | undefined>;
+    fetchAllBuckets(): Promise<{
+        buckets: Models.Bucket[];
+    }>;
     wipeOtherDatabases(databasesToKeep: Models.Database[]): Promise<void>;
     wipeUsers(): Promise<void>;
     backupDatabase(database: Models.Database, format?: 'json' | 'zip'): Promise<void>;
@@ -78,7 +82,9 @@ export declare class UtilsController {
     }[], collections?: Models.Collection[]): Promise<void>;
     generateSchemas(): Promise<void>;
     importData(options?: SetupOptions): Promise<void>;
-    synchronizeConfigurations(databases?: Models.Database[], config?: AppwriteConfig): Promise<void>;
+    synchronizeConfigurations(databases?: Models.Database[], config?: AppwriteConfig, databaseSelections?: DatabaseSelection[], bucketSelections?: BucketSelection[]): Promise<void>;
+    selectivePull(databaseSelections: DatabaseSelection[], bucketSelections: BucketSelection[]): Promise<void>;
+    selectivePush(databaseSelections: DatabaseSelection[], bucketSelections: BucketSelection[]): Promise<void>;
     syncDb(databases?: Models.Database[], collections?: Models.Collection[]): Promise<void>;
     getAppwriteFolderPath(): string | undefined;
     transferData(options: TransferOptions): Promise<void>;

package/dist/utilsController.js

@@ -1,6 +1,7 @@
 import { Client, Databases, Query, Storage, Users, } from "node-appwrite";
 import {} from "appwrite-utils";
-import { loadConfig, loadConfigWithPath, findAppwriteConfig, findFunctionsDir, } from "./utils/loadConfigs.js";
+import { findAppwriteConfig, findFunctionsDir, } from "./utils/loadConfigs.js";
+import { normalizeFunctionName, validateFunctionDirectory } from './functions/pathResolution.js';
 import { UsersController } from "./users/methods.js";
 import { AppwriteToX } from "./migrations/appwriteToX.js";
 import { ImportController } from "./migrations/importController.js";
@@ -25,6 +26,7 @@ import { configureLogging, updateLogger, logger } from "./shared/logging.js";
 import { MessageFormatter, Messages } from "./shared/messageFormatter.js";
 import { SchemaGenerator } from "./shared/schemaGenerator.js";
 import { findYamlConfig } from "./config/yamlConfig.js";
+import { createImportSchemas } from "./migrations/yaml/generateImportSchemas.js";
 import { validateCollectionsTablesConfig, reportValidationResults, validateWithStrictMode } from "./config/configValidation.js";
 import { ConfigManager } from "./config/ConfigManager.js";
 import { ClientFactory } from "./utils/ClientFactory.js";
@@ -38,6 +40,26 @@ export class UtilsController {
      * Get the UtilsController singleton instance
      */
     static getInstance(currentUserDir, directConfig) {
+        // Clear instance if currentUserDir has changed
+        if (UtilsController.instance &&
+            UtilsController.instance.currentUserDir !== currentUserDir) {
+            logger.debug(`Clearing singleton: currentUserDir changed from ${UtilsController.instance.currentUserDir} to ${currentUserDir}`, { prefix: "UtilsController" });
+            UtilsController.clearInstance();
+        }
+        // Clear instance if directConfig endpoint or project has changed
+        if (UtilsController.instance && directConfig) {
+            const existingConfig = UtilsController.instance.config;
+            if (existingConfig) {
+                const endpointChanged = directConfig.appwriteEndpoint &&
+                    existingConfig.appwriteEndpoint !== directConfig.appwriteEndpoint;
+                const projectChanged = directConfig.appwriteProject &&
+                    existingConfig.appwriteProject !== directConfig.appwriteProject;
+                if (endpointChanged || projectChanged) {
+                    logger.debug("Clearing singleton: endpoint or project changed", { prefix: "UtilsController" });
+                    UtilsController.clearInstance();
+                }
+            }
+        }
         if (!UtilsController.instance) {
             UtilsController.instance = new UtilsController(currentUserDir, directConfig);
         }
@@ -225,6 +247,24 @@ export class UtilsController {
         ]);
         return dbs.databases;
     }
+    async fetchAllBuckets() {
+        await this.init();
+        if (!this.storage) {
+            MessageFormatter.warning("Storage not initialized - buckets will be empty", { prefix: "Controller" });
+            return { buckets: [] };
+        }
+        try {
+            const result = await this.storage.listBuckets([
+                Query.limit(1000) // Increase limit to get all buckets
+            ]);
+            MessageFormatter.success(`Found ${result.buckets.length} buckets`, { prefix: "Controller" });
+            return result;
+        }
+        catch (error) {
+            MessageFormatter.error(`Failed to fetch buckets: ${error.message || error}`, error instanceof Error ? error : undefined, { prefix: "Controller" });
+            return { buckets: [] };
+        }
+    }
     async wipeOtherDatabases(databasesToKeep) {
         await this.init();
         if (!this.database) {
@@ -276,9 +316,14 @@ export class UtilsController {
         for (const entry of entries) {
             if (entry.isDirectory()) {
                 const functionPath = path.join(functionsDir, entry.name);
-                // Match with config functions by name
+                // Validate it's a function directory
+                if (!validateFunctionDirectory(functionPath)) {
+                    continue; // Skip invalid directories
+                }
+                // Match with config functions using normalized names
                 if (this.config?.functions) {
-                    const matchingFunc = this.config.functions.find((f) => f.name.toLowerCase() === entry.name.toLowerCase());
+                    const normalizedEntryName = normalizeFunctionName(entry.name);
+                    const matchingFunc = this.config.functions.find((f) => normalizeFunctionName(f.name) === normalizedEntryName);
                     if (matchingFunc) {
                         functionDirMap.set(matchingFunc.name, functionPath);
                     }
@@ -403,20 +448,22 @@ export class UtilsController {
     async generateSchemas() {
         // Schema generation doesn't need Appwrite connection, just config
         if (!this.config) {
-            if (this.appwriteFolderPath && this.appwriteConfigPath) {
-                MessageFormatter.progress("Loading config from file...", { prefix: "Config" });
-                try {
-                    const { config, actualConfigPath } = await loadConfigWithPath(this.appwriteFolderPath, { validate: false, strictMode: false, reportValidation: false });
-                    this.config = config;
-                    MessageFormatter.info(`Loaded config from: ${actualConfigPath}`, { prefix: "Config" });
-                }
-                catch (error) {
-                    MessageFormatter.error("Failed to load config from file", error instanceof Error ? error : undefined, { prefix: "Config" });
-                    return;
+            MessageFormatter.progress("Loading config from ConfigManager...", { prefix: "Config" });
+            try {
+                const configManager = ConfigManager.getInstance();
+                // Load config if not already loaded
+                if (!configManager.hasConfig()) {
+                    await configManager.loadConfig({
+                        configDir: this.currentUserDir,
+                        validate: false,
+                        strictMode: false,
+                    });
                 }
+                this.config = configManager.getConfig();
+                MessageFormatter.info("Config loaded successfully from ConfigManager", { prefix: "Config" });
             }
-            else {
-                MessageFormatter.error("No configuration available", undefined, { prefix: "Controller" });
+            catch (error) {
+                MessageFormatter.error("Failed to load config", error instanceof Error ? error : undefined, { prefix: "Config" });
                 return;
             }
         }
@@ -448,7 +495,7 @@ export class UtilsController {
         const importController = new ImportController(this.config, this.database, this.storage, this.appwriteFolderPath, importDataActions, options, options.databases);
         await importController.run(options.collections);
     }
-    async synchronizeConfigurations(databases, config) {
+    async synchronizeConfigurations(databases, config, databaseSelections, bucketSelections) {
         await this.init();
         if (!this.storage) {
             MessageFormatter.error("Storage not initialized", undefined, { prefix: "Controller" });
@@ -463,8 +510,25 @@ export class UtilsController {
             MessageFormatter.error("Failed to get appwriteFolderPath", undefined, { prefix: "Controller" });
             return;
         }
+        // If selections are provided, filter the databases accordingly
+        let filteredDatabases = databases;
+        if (databaseSelections && databaseSelections.length > 0) {
+            // Convert selections to Models.Database format
+            filteredDatabases = [];
+            const allDatabases = databases ? databases : await fetchAllDatabases(this.database);
+            for (const selection of databaseSelections) {
+                const database = allDatabases.find(db => db.$id === selection.databaseId);
+                if (database) {
+                    filteredDatabases.push(database);
+                }
+                else {
+                    MessageFormatter.warning(`Database with ID ${selection.databaseId} not found`, { prefix: "Controller" });
+                }
+            }
+            MessageFormatter.info(`Syncing ${filteredDatabases.length} selected databases out of ${allDatabases.length} available`, { prefix: "Controller" });
+        }
         const appwriteToX = new AppwriteToX(configToUse, this.appwriteFolderPath, this.storage);
-        await appwriteToX.toSchemas(databases);
+        await appwriteToX.toSchemas(filteredDatabases);
         // Update the controller's config with the synchronized collections
         this.config = appwriteToX.updatedConfig;
         // Write the updated config back to disk
@@ -472,6 +536,123 @@ export class UtilsController {
         const yamlConfigPath = findYamlConfig(this.appwriteFolderPath);
         const isYamlProject = !!yamlConfigPath;
         await generator.updateConfig(this.config, isYamlProject);
+        // Regenerate JSON schemas to reflect any table terminology fixes
+        try {
+            MessageFormatter.progress("Regenerating JSON schemas...", { prefix: "Sync" });
+            await createImportSchemas(this.appwriteFolderPath);
+            MessageFormatter.success("JSON schemas regenerated successfully", { prefix: "Sync" });
+        }
+        catch (error) {
+            // Log error but don't fail the sync process
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            MessageFormatter.warning(`Failed to regenerate JSON schemas, but sync completed: ${errorMessage}`, { prefix: "Sync" });
+            logger.warn("Schema regeneration failed during sync:", error);
+        }
+    }
+    async selectivePull(databaseSelections, bucketSelections) {
+        await this.init();
+        if (!this.database) {
+            MessageFormatter.error("Database not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        MessageFormatter.progress("Starting selective pull (Appwrite → local config)...", { prefix: "Controller" });
+        // Convert database selections to Models.Database format
+        const selectedDatabases = [];
+        for (const dbSelection of databaseSelections) {
+            // Get the full database object from the controller
+            const databases = await fetchAllDatabases(this.database);
+            const database = databases.find(db => db.$id === dbSelection.databaseId);
+            if (database) {
+                selectedDatabases.push(database);
+                MessageFormatter.info(`Selected database: ${database.name} (${database.$id})`, { prefix: "Controller" });
+                // Log selected tables for this database
+                if (dbSelection.tableIds && dbSelection.tableIds.length > 0) {
+                    MessageFormatter.info(`  Tables: ${dbSelection.tableIds.join(', ')}`, { prefix: "Controller" });
+                }
+            }
+            else {
+                MessageFormatter.warning(`Database with ID ${dbSelection.databaseId} not found`, { prefix: "Controller" });
+            }
+        }
+        if (selectedDatabases.length === 0) {
+            MessageFormatter.warning("No valid databases selected for pull", { prefix: "Controller" });
+            return;
+        }
+        // Log bucket selections if provided
+        if (bucketSelections && bucketSelections.length > 0) {
+            MessageFormatter.info(`Selected ${bucketSelections.length} buckets:`, { prefix: "Controller" });
+            for (const bucketSelection of bucketSelections) {
+                const dbInfo = bucketSelection.databaseId ? ` (DB: ${bucketSelection.databaseId})` : '';
+                MessageFormatter.info(`  - ${bucketSelection.bucketName} (${bucketSelection.bucketId})${dbInfo}`, { prefix: "Controller" });
+            }
+        }
+        // Perform selective sync using the enhanced synchronizeConfigurations method
+        await this.synchronizeConfigurations(selectedDatabases, this.config, databaseSelections, bucketSelections);
+        MessageFormatter.success("Selective pull completed successfully! Remote config pulled to local.", { prefix: "Controller" });
+    }
+    async selectivePush(databaseSelections, bucketSelections) {
+        await this.init();
+        if (!this.database) {
+            MessageFormatter.error("Database not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        MessageFormatter.progress("Starting selective push (local config → Appwrite)...", { prefix: "Controller" });
+        // Convert database selections to Models.Database format
+        const selectedDatabases = [];
+        for (const dbSelection of databaseSelections) {
+            // Get the full database object from the controller
+            const databases = await fetchAllDatabases(this.database);
+            const database = databases.find(db => db.$id === dbSelection.databaseId);
+            if (database) {
+                selectedDatabases.push(database);
+                MessageFormatter.info(`Selected database: ${database.name} (${database.$id})`, { prefix: "Controller" });
+                // Log selected tables for this database
+                if (dbSelection.tableIds && dbSelection.tableIds.length > 0) {
+                    MessageFormatter.info(`  Tables: ${dbSelection.tableIds.join(', ')}`, { prefix: "Controller" });
+                }
+            }
+            else {
+                MessageFormatter.warning(`Database with ID ${dbSelection.databaseId} not found`, { prefix: "Controller" });
+            }
+        }
+        if (selectedDatabases.length === 0) {
+            MessageFormatter.warning("No valid databases selected for push", { prefix: "Controller" });
+            return;
+        }
+        // Log bucket selections if provided
+        if (bucketSelections && bucketSelections.length > 0) {
+            MessageFormatter.info(`Selected ${bucketSelections.length} buckets:`, { prefix: "Controller" });
+            for (const bucketSelection of bucketSelections) {
+                const dbInfo = bucketSelection.databaseId ? ` (DB: ${bucketSelection.databaseId})` : '';
+                MessageFormatter.info(`  - ${bucketSelection.bucketName} (${bucketSelection.bucketId})${dbInfo}`, { prefix: "Controller" });
+            }
+        }
+        // PUSH OPERATION: Push local configuration to Appwrite
+        // Build selected collections/tables from databaseSelections
+        const selectedCollections = [];
+        // Get all collections/tables from config (they're at the root level, not nested in databases)
+        const allCollections = this.config?.collections || this.config?.tables || [];
+        // Collect all selected table IDs from all database selections
+        const selectedTableIds = new Set();
+        for (const dbSelection of databaseSelections) {
+            for (const tableId of dbSelection.tableIds) {
+                selectedTableIds.add(tableId);
+            }
+        }
+        // Filter to only the selected table IDs
+        for (const collection of allCollections) {
+            const collectionId = collection.$id || collection.id;
+            if (selectedTableIds.has(collectionId)) {
+                selectedCollections.push(collection);
+            }
+        }
+        MessageFormatter.info(`Pushing ${selectedCollections.length} selected tables/collections to Appwrite`, { prefix: "Controller" });
+        // Ensure databases exist
+        await this.ensureDatabasesExist(selectedDatabases);
+        await this.ensureDatabaseConfigBucketsExist(selectedDatabases);
+        // Create/update ONLY the selected collections/tables
+        await this.createOrUpdateCollectionsForDatabases(selectedDatabases, selectedCollections);
+        MessageFormatter.success("Selective push completed successfully! Local config pushed to Appwrite.", { prefix: "Controller" });
     }
     async syncDb(databases = [], collections = []) {
         await this.init();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "1.7.7",
+  "version": "1.7.9",
   "main": "src/main.ts",
   "type": "module",
   "repository": {
@@ -24,7 +24,9 @@
     "appwrite-migrate": "./dist/main.js"
   },
   "scripts": {
-    "build": "bun run tsc",
+    "build": "bun run tsc && bun run copy-templates",
+    "prebuild": "rm -rf dist",
+    "copy-templates": "tsx scripts/copy-templates.ts",
     "start": "tsx --no-cache src/main.ts",
     "deploy": "bun run build && npm publish --access public",
     "test": "jest",

package/scripts/copy-templates.ts

@@ -0,0 +1,23 @@
+import { cpSync, mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+const src = join(process.cwd(), 'src', 'functions', 'templates');
+const dest = join(process.cwd(), 'dist', 'functions', 'templates');
+
+// Verify source exists
+if (!existsSync(src)) {
+  console.error('❌ Error: Template source directory not found:', src);
+  process.exit(1);
+}
+
+// Create destination directory
+mkdirSync(dest, { recursive: true });
+
+// Copy templates recursively
+try {
+  cpSync(src, dest, { recursive: true });
+  console.log('✓ Templates copied to dist/functions/templates/');
+} catch (error) {
+  console.error('❌ Failed to copy templates:', error);
+  process.exit(1);
+}