@akis05/akis 0.1.0

package/dist/cli/commands/init.js

@@ -0,0 +1,439 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+async function prompt(question, defaultValue) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const defaultText = defaultValue ? ` (${defaultValue})` : "";
+    return new Promise((resolve) => {
+        rl.question(`${question}${defaultText}: `, (answer) => {
+            rl.close();
+            resolve(answer.trim() || defaultValue || "");
+        });
+    });
+}
+const TYPES_TEMPLATE = `/* ═════════════════════════════════════════════════════════════════════════════
+   AKIS — TypeScript Types pour Appwrite
+   ═════════════════════════════════════════════════════════════════════════════ */
+
+/* ─────────────────────────────────────────────────────────────────────────────
+   Exemple de collection
+   ───────────────────────────────────────────────────────────────────────────── */
+
+export type Client = {
+  _id: string;
+  _creationTime: number;
+  nom: string;
+  email?: string;
+  telephone?: string;
+  adresse?: string;
+  note?: string;
+  storeId: string;
+  createdAt: number;
+  deletedAt?: number;
+};
+
+/* ─────────────────────────────────────────────────────────────────────────────
+   Utilitaires génériques
+   ───────────────────────────────────────────────────────────────────────────── */
+
+export type NewDoc<T> = Omit<T, "_id" | "_creationTime">;
+export type UpdateDoc<T> = Partial<Omit<T, "_id" | "_creationTime">>;
+`;
+const SETUP_COLLECTIONS_TEMPLATE = `import { Databases, ID, DatabasesIndexType, Query } from "node-appwrite";
+import { collections, AttributeDefinition, CollectionSchema } from "./schema";
+
+function delay(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function createAttribute(
+  databases: Databases,
+  databaseId: string,
+  collectionId: string,
+  attr: AttributeDefinition
+): Promise<void> {
+  const baseParams = {
+    databaseId,
+    collectionId,
+    key: attr.key,
+    required: attr.required,
+  };
+
+  switch (attr.type) {
+    case "string":
+      await databases.createStringAttribute({
+        ...baseParams,
+        size: attr.size || 255,
+      });
+      break;
+    case "integer":
+      await databases.createIntegerAttribute(baseParams);
+      break;
+    case "float":
+      await databases.createFloatAttribute(baseParams);
+      break;
+    case "boolean":
+      await databases.createBooleanAttribute(baseParams);
+      break;
+    case "datetime":
+      await databases.createDatetimeAttribute(baseParams);
+      break;
+    case "enum":
+      await databases.createEnumAttribute({
+        ...baseParams,
+        elements: attr.enumValues || [],
+      });
+      break;
+    case "string[]":
+      await databases.createStringAttribute({
+        ...baseParams,
+        size: attr.size || 255,
+        array: true,
+      });
+      break;
+    case "integer[]":
+      await databases.createIntegerAttribute({
+        ...baseParams,
+        array: true,
+      });
+      break;
+  }
+}
+
+export async function setupCollection(
+  databases: Databases,
+  databaseId: string,
+  schema: CollectionSchema
+): Promise<{ success: boolean; collectionId: string; error?: string }> {
+  try {
+    const collectionId = ID.unique();
+    
+    await databases.createCollection({
+      databaseId,
+      collectionId,
+      name: schema.name,
+      permissions: [],
+      documentSecurity: false,
+    });
+
+    for (const attr of schema.attributes) {
+      try {
+        await createAttribute(databases, databaseId, collectionId, attr);
+        await delay(300);
+      } catch (error) {
+        console.error(\`Error creating attribute \${attr.key}:\`, error);
+      }
+    }
+
+    await delay(2000);
+
+    if (schema.indexes && schema.indexes.length > 0) {
+      for (const index of schema.indexes) {
+        const indexType = index.type === "key" 
+          ? DatabasesIndexType.Key 
+          : index.type === "unique" 
+            ? DatabasesIndexType.Unique 
+            : DatabasesIndexType.Fulltext;
+        
+        let retries = 5;
+        while (retries > 0) {
+          try {
+            await databases.createIndex({
+              databaseId,
+              collectionId,
+              key: index.key,
+              type: indexType,
+              attributes: index.attributes,
+            });
+            await delay(500);
+            break;
+          } catch (indexError: unknown) {
+            const appwriteError = indexError as { type?: string };
+            if (appwriteError.type === "attribute_not_available" && retries > 1) {
+              retries--;
+              await delay(3000);
+            } else {
+              console.error(\`Error creating index \${index.key}:\`, indexError);
+              break;
+            }
+          }
+        }
+      }
+    }
+
+    return { success: true, collectionId };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return { success: false, collectionId: "", error: errorMessage };
+  }
+}
+
+export async function setupAllCollections(
+  databases: Databases,
+  databaseId: string
+): Promise<{ name: string; success: boolean; collectionId: string; error?: string }[]> {
+  const results: { name: string; success: boolean; collectionId: string; error?: string }[] = [];
+
+  for (const schema of collections) {
+    const result = await setupCollection(databases, databaseId, schema);
+    results.push({ name: schema.name, ...result });
+    await delay(500);
+  }
+
+  return results;
+}
+
+export async function deleteAllCollections(
+  databases: Databases,
+  databaseId: string
+): Promise<{ deleted: number; errors: string[] }> {
+  const errors: string[] = [];
+  let deleted = 0;
+
+  try {
+    const response = await databases.listCollections({
+      databaseId,
+      queries: [Query.limit(100)],
+    });
+
+    for (const collection of response.collections) {
+      try {
+        await databases.deleteCollection({
+          databaseId,
+          collectionId: collection.$id,
+        });
+        deleted++;
+        await delay(200);
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        errors.push(\`\${collection.name}: \${errorMessage}\`);
+      }
+    }
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    errors.push(\`Failed to list collections: \${errorMessage}\`);
+  }
+
+  return { deleted, errors };
+}
+
+export { collections };
+`;
+const SCHEMA_TEMPLATE = `export type AttributeType =
+  | "string"
+  | "integer"
+  | "float"
+  | "boolean"
+  | "datetime"
+  | "enum"
+  | "string[]"
+  | "integer[]";
+
+export interface AttributeDefinition {
+  key: string;
+  type: AttributeType;
+  required: boolean;
+  size?: number;
+  enumValues?: string[];
+  default?: string | number | boolean | null;
+}
+
+export type IndexType = "key" | "unique" | "fulltext";
+
+export interface IndexDefinition {
+  key: string;
+  type: IndexType;
+  attributes: string[];
+  orders?: ("ASC" | "DESC")[];
+}
+
+export interface CollectionSchema {
+  name: string;
+  attributes: AttributeDefinition[];
+  indexes?: IndexDefinition[];
+}
+
+// Définissez vos collections ici
+export const collections: CollectionSchema[] = [
+  {
+    name: "clients",
+    attributes: [
+      { key: "nom", type: "string", required: true, size: 255 },
+      { key: "email", type: "string", required: false, size: 255 },
+      { key: "telephone", type: "string", required: false, size: 50 },
+      { key: "adresse", type: "string", required: false, size: 500 },
+      { key: "note", type: "string", required: false, size: 2000 },
+      { key: "storeId", type: "string", required: true, size: 36 },
+      { key: "createdAt", type: "integer", required: true },
+      { key: "deletedAt", type: "integer", required: false },
+    ],
+    indexes: [
+      { key: "idx_storeId", type: "key", attributes: ["storeId"] },
+    ],
+  },
+];
+`;
+const CLIENT_TEMPLATE = `import { Client, Databases } from "node-appwrite";
+
+const APPWRITE_ENDPOINT = process.env.APPWRITE_ENDPOINT || "https://cloud.appwrite.io/v1";
+const APPWRITE_PROJECT_ID = process.env.APPWRITE_PROJECT_ID || "";
+const APPWRITE_API_KEY = process.env.APPWRITE_API_KEY || "";
+const APPWRITE_DATABASE_ID = process.env.APPWRITE_DATABASE_ID || "";
+
+export function createAdminClient() {
+  const client = new Client()
+    .setEndpoint(APPWRITE_ENDPOINT)
+    .setProject(APPWRITE_PROJECT_ID)
+    .setKey(APPWRITE_API_KEY);
+
+  return {
+    client,
+    databases: new Databases(client),
+  };
+}
+
+export const config = {
+  endpoint: APPWRITE_ENDPOINT,
+  projectId: APPWRITE_PROJECT_ID,
+  databaseId: APPWRITE_DATABASE_ID,
+};
+`;
+const ENV_TEMPLATE = `# Appwrite Configuration
+APPWRITE_ENDPOINT=https://cloud.appwrite.io/v1
+APPWRITE_PROJECT_ID=
+APPWRITE_DATABASE_ID=
+APPWRITE_API_KEY=
+`;
+async function init(options) {
+    console.log("\n🚀 AKIS Init - Initialisation du projet\n");
+    const cwd = process.cwd();
+    const libPath = path.join(cwd, "core", "appwrite-model");
+    const typesPath = path.join(libPath, "types.ts");
+    const clientPath = path.join(libPath, "client.ts");
+    const schemaPath = path.join(libPath, "schema.ts");
+    const setupPath = path.join(libPath, "setup-collections.ts");
+    // Check if files already exist
+    const existingFiles = [];
+    if (fs.existsSync(typesPath))
+        existingFiles.push("core/appwrite-model/types.ts");
+    if (fs.existsSync(clientPath))
+        existingFiles.push("core/appwrite-model/client.ts");
+    if (fs.existsSync(schemaPath))
+        existingFiles.push("core/appwrite-model/schema.ts");
+    if (fs.existsSync(setupPath))
+        existingFiles.push("core/appwrite-model/setup-collections.ts");
+    if (existingFiles.length > 0 && !options.force) {
+        console.log("⚠️  Les fichiers suivants existent déjà:");
+        for (const file of existingFiles) {
+            console.log(`   - ${file}`);
+        }
+        console.log("\n   Utilisez --force pour les écraser\n");
+        return;
+    }
+    // Create directories
+    console.log("📁 Création des dossiers...");
+    if (!fs.existsSync(libPath)) {
+        fs.mkdirSync(libPath, { recursive: true });
+        console.log("   ✓ core/appwrite-model/");
+    }
+    else {
+        console.log("   ⏭️  core/appwrite-model/ (existe déjà)");
+    }
+    // Create types.ts
+    if (!fs.existsSync(typesPath) || options.force) {
+        fs.writeFileSync(typesPath, TYPES_TEMPLATE);
+        console.log("   ✓ core/appwrite-model/types.ts");
+    }
+    else {
+        console.log("   ⏭️  core/appwrite-model/types.ts (existe déjà)");
+    }
+    // Create client.ts
+    if (!fs.existsSync(clientPath) || options.force) {
+        fs.writeFileSync(clientPath, CLIENT_TEMPLATE);
+        console.log("   ✓ core/appwrite-model/client.ts");
+    }
+    else {
+        console.log("   ⏭️  core/appwrite-model/client.ts (existe déjà)");
+    }
+    // Create schema.ts
+    if (!fs.existsSync(schemaPath) || options.force) {
+        fs.writeFileSync(schemaPath, SCHEMA_TEMPLATE);
+        console.log("   ✓ core/appwrite-model/schema.ts");
+    }
+    else {
+        console.log("   ⏭️  core/appwrite-model/schema.ts (existe déjà)");
+    }
+    // Create setup-collections.ts
+    if (!fs.existsSync(setupPath) || options.force) {
+        fs.writeFileSync(setupPath, SETUP_COLLECTIONS_TEMPLATE);
+        console.log("   ✓ core/appwrite-model/setup-collections.ts");
+    }
+    else {
+        console.log("   ⏭️  core/appwrite-model/setup-collections.ts (existe déjà)");
+    }
+    console.log(`
+✨ Initialisation terminée!
+
+📁 Structure créée:
+   core/
+   └── appwrite-model/
+       ├── types.ts              # Définitions TypeScript
+       ├── schema.ts             # Schéma des collections Appwrite
+       ├── client.ts             # Client Appwrite
+       └── setup-collections.ts  # Fonctions de setup
+
+📖 Prochaines étapes:
+   1. Configurez vos variables d'environnement (.env)
+   2. Définissez vos types dans core/appwrite-model/types.ts
+   3. Définissez vos collections dans core/appwrite-model/schema.ts
+   4. Exécutez: pnpm akis migrate
+   5. Vérifiez avec: pnpm akis status
+
+📚 Commandes disponibles:
+   pnpm akis status              # Voir l'état des collections
+   pnpm akis migrate             # Créer les collections manquantes
+   pnpm akis migrate --name X    # Créer une collection spécifique
+   pnpm akis update              # Mettre à jour les collections
+   pnpm akis delete              # Supprimer les collections
+`);
+}
+//# sourceMappingURL=init.js.map

package/dist/cli/commands/init.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.js","sourceRoot":"","sources":["../../../src/cli/commands/init.ts"],"names":[],"mappings":"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"}

package/dist/cli/commands/migrate.d.ts

@@ -0,0 +1,7 @@
+interface MigrateOptions {
+    dryRun?: boolean;
+    name?: string;
+}
+export declare function migrate(options: MigrateOptions): Promise<void>;
+export {};
+//# sourceMappingURL=migrate.d.ts.map

package/dist/cli/commands/migrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/migrate.ts"],"names":[],"mappings":"AAcA,UAAU,cAAc;IACtB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AA4DD,wBAAsB,OAAO,CAAC,OAAO,EAAE,cAAc,iBAyJpD"}

package/dist/cli/commands/migrate.js

@@ -0,0 +1,239 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrate = migrate;
+const node_appwrite_1 = require("node-appwrite");
+const path = __importStar(require("path"));
+const dotenv = __importStar(require("dotenv"));
+const parser_1 = require("../parser");
+// Load env
+dotenv.config({ path: path.resolve(process.cwd(), ".env") });
+dotenv.config({ path: path.resolve(process.cwd(), ".env.local") });
+const APPWRITE_ENDPOINT = process.env.APPWRITE_ENDPOINT || "https://cloud.appwrite.io/v1";
+const APPWRITE_PROJECT_ID = process.env.APPWRITE_PROJECT_ID || "";
+const APPWRITE_API_KEY = process.env.APPWRITE_API_KEY || "";
+const APPWRITE_DATABASE_ID = process.env.APPWRITE_DATABASE_ID || "";
+async function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function createAttribute(databases, databaseId, collectionId, field) {
+    const baseParams = {
+        databaseId,
+        collectionId,
+        key: field.key,
+        required: field.required,
+    };
+    switch (field.type) {
+        case "string":
+            await databases.createStringAttribute({
+                ...baseParams,
+                size: field.size || 255,
+            });
+            break;
+        case "integer":
+            await databases.createIntegerAttribute(baseParams);
+            break;
+        case "float":
+            await databases.createFloatAttribute(baseParams);
+            break;
+        case "boolean":
+            await databases.createBooleanAttribute(baseParams);
+            break;
+        case "enum":
+            await databases.createEnumAttribute({
+                ...baseParams,
+                elements: field.enumValues || [],
+            });
+            break;
+        case "string[]":
+            await databases.createStringAttribute({
+                ...baseParams,
+                size: field.size || 255,
+                array: true,
+            });
+            break;
+        case "integer[]":
+            await databases.createIntegerAttribute({
+                ...baseParams,
+                array: true,
+            });
+            break;
+        case "datetime":
+            await databases.createDatetimeAttribute(baseParams);
+            break;
+    }
+}
+async function migrate(options) {
+    const targetName = options.name;
+    console.log(`\n🚀 AKIS Migrate - ${targetName ? `Création de "${targetName}"` : "Création des collections manquantes"}\n`);
+    if (!APPWRITE_API_KEY) {
+        console.error("❌ APPWRITE_API_KEY non configurée dans .env");
+        process.exit(1);
+    }
+    if (!APPWRITE_DATABASE_ID) {
+        console.error("❌ APPWRITE_DATABASE_ID non configurée dans .env");
+        process.exit(1);
+    }
+    // Parse types.ts
+    const typesPath = path.resolve(process.cwd(), "core/appwrite-model/types.ts");
+    console.log(`📖 Lecture de ${typesPath}...`);
+    let collections;
+    try {
+        const allCollections = (0, parser_1.parseTypesFile)(typesPath);
+        if (targetName) {
+            collections = allCollections.filter((c) => c.name === targetName);
+            if (collections.length === 0) {
+                console.error(`❌ Collection "${targetName}" non trouvée dans types.ts`);
+                console.log(`   Collections disponibles: ${allCollections.map((c) => c.name).join(", ")}`);
+                process.exit(1);
+            }
+        }
+        else {
+            collections = allCollections;
+        }
+        console.log(`   ${collections.length} collection(s) à traiter\n`);
+    }
+    catch (error) {
+        console.error("❌ Erreur lors de la lecture de types.ts:", error);
+        process.exit(1);
+    }
+    if (options.dryRun) {
+        console.log("🔍 Mode dry-run - Aucune modification ne sera effectuée\n");
+        for (const col of collections) {
+            console.log(`   📦 ${col.name} (${col.fields.length} champs)`);
+            for (const field of col.fields) {
+                const req = field.required ? "required" : "optional";
+                const extra = field.enumValues ? ` [${field.enumValues.join(", ")}]` : field.size ? ` (${field.size})` : "";
+                console.log(`      - ${field.key}: ${field.type} ${req}${extra}`);
+            }
+        }
+        return;
+    }
+    // Connect to Appwrite
+    const client = new node_appwrite_1.Client()
+        .setEndpoint(APPWRITE_ENDPOINT)
+        .setProject(APPWRITE_PROJECT_ID)
+        .setKey(APPWRITE_API_KEY);
+    const databases = new node_appwrite_1.Databases(client);
+    // Get existing collections
+    console.log("📡 Connexion à Appwrite...");
+    let existingCollections = [];
+    try {
+        const response = await databases.listCollections({
+            databaseId: APPWRITE_DATABASE_ID,
+            queries: [node_appwrite_1.Query.limit(100)],
+        });
+        existingCollections = response.collections.map((c) => c.name);
+        console.log(`   ${existingCollections.length} collections existantes\n`);
+    }
+    catch (error) {
+        console.error("❌ Erreur lors de la connexion:", error);
+        process.exit(1);
+    }
+    // Create missing collections
+    let created = 0;
+    let skipped = 0;
+    for (const col of collections) {
+        if (existingCollections.includes(col.name)) {
+            console.log(`⏭️  ${col.name} - existe déjà`);
+            skipped++;
+            continue;
+        }
+        console.log(`\n📦 Création de ${col.name}...`);
+        try {
+            const collectionId = node_appwrite_1.ID.unique();
+            await databases.createCollection({
+                databaseId: APPWRITE_DATABASE_ID,
+                collectionId,
+                name: col.name,
+                permissions: [],
+                documentSecurity: false,
+            });
+            // Create attributes
+            for (const field of col.fields) {
+                try {
+                    await createAttribute(databases, APPWRITE_DATABASE_ID, collectionId, field);
+                    console.log(`   ✓ ${field.key}`);
+                    await delay(300);
+                }
+                catch (error) {
+                    const err = error;
+                    console.log(`   ✗ ${field.key}: ${err.message || error}`);
+                }
+            }
+            // Wait for attributes to be available
+            await delay(2000);
+            // Create indexes
+            const indexes = (0, parser_1.generateIndexes)(col);
+            for (const index of indexes) {
+                let retries = 3;
+                while (retries > 0) {
+                    try {
+                        await databases.createIndex({
+                            databaseId: APPWRITE_DATABASE_ID,
+                            collectionId,
+                            key: index.key,
+                            type: node_appwrite_1.DatabasesIndexType.Key,
+                            attributes: index.attributes,
+                        });
+                        console.log(`   🔑 ${index.key}`);
+                        await delay(300);
+                        break;
+                    }
+                    catch (error) {
+                        const err = error;
+                        if (err.type === "attribute_not_available" && retries > 1) {
+                            retries--;
+                            await delay(2000);
+                        }
+                        else {
+                            console.log(`   ⚠️  Index ${index.key} ignoré`);
+                            break;
+                        }
+                    }
+                }
+            }
+            created++;
+            console.log(`   ✅ ${col.name} créée`);
+        }
+        catch (error) {
+            const err = error;
+            console.error(`   ❌ Erreur: ${err.message || error}`);
+        }
+        await delay(500);
+    }
+    console.log(`\n✨ Migration terminée: ${created} créées, ${skipped} ignorées\n`);
+}
+//# sourceMappingURL=migrate.js.map