silgi 0.28.4 → 0.28.6

package/dist/cli/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from 'citty';
 
-const version = "0.28.4";
+const version = "0.28.6";
 const packageJson = {
 	version: version};
 

package/dist/kit/index.d.mts

@@ -1,6 +1,7 @@
 import { SilgiCLI, ModuleOptionsCustom, ModuleDefinition, SilgiModule, ServiceParseModule, SilgiPreset, SilgiPresetMeta, SilgiTemplate, ResolvedSilgiTemplate, SilgiEvents } from 'silgi/types';
 import { Buffer } from 'node:buffer';
 import { ConsolaOptions, ConsolaInstance } from 'consola';
+import * as rfc6902 from 'rfc6902';
 import { IncomingMessage, ServerResponse } from 'node:http';
 
 declare function hasError(type: SilgiCLI['errors'][0]['type'], silgi?: SilgiCLI): boolean;
@@ -53,6 +54,115 @@ declare function isH3(): boolean;
 
 declare function useLogger(tag?: string, options?: Partial<ConsolaOptions>): ConsolaInstance;
 
+/**
+ * Migration bilgisi
+ */
+interface MigrationInfo {
+    /** Migration zaman damgası */
+    timestamp: number;
+    /** Migration dosya adı */
+    file: string;
+    /** Migration oluşturulma tarihi */
+    created: string;
+    /** Migration açıklaması */
+    description?: string;
+    /** Patch formatında mı? */
+    isPatch?: boolean;
+}
+/**
+ * İzin migration verisi
+ */
+interface MigrationData {
+}
+/**
+ * JSON Patch formatı (RFC6902)
+ */
+type JsonPatch = Array<rfc6902.Operation>;
+/**
+ * Migration durumu
+ */
+declare enum MigrationStatus {
+    SUCCESS = "success",
+    ERROR = "error",
+    SKIPPED = "skipped"
+}
+/**
+ * Migration options
+ */
+interface MigrationOptions {
+    /** Migration açıklaması (opsiyonel) */
+    description?: string;
+    /** Değişiklikler için log göster */
+    verbose?: boolean;
+    /** JSON dosyasını pretty-print formatında kaydet */
+    prettyPrint?: boolean;
+    /** Patch formatını kullanmalı mı? */
+    usePatch?: boolean;
+    /** Değişiklik yoksa dosya oluşturma */
+    skipIfNoChanges?: boolean;
+}
+/**
+ * Migration başlatma sonucu
+ */
+interface MigrationResult {
+    /** İşlem başarılı mı? */
+    success: boolean;
+    /** Migration durumu */
+    status: MigrationStatus;
+    /** Migration dosya yolu (başarılıysa) */
+    filePath?: string;
+    /** Migration zaman damgası (başarılıysa) */
+    timestamp?: number;
+    /** Hata mesajı (başarısızsa) */
+    error?: string;
+    /** Patch türünde mi? */
+    isPatch?: boolean;
+    /** Migration verisi */
+    data?: MigrationData[] | JsonPatch;
+}
+/**
+ * Migration oluşturur
+ *
+ * @param data Migration verisi
+ * @param directoryPath Migration dizini
+ * @param fileNamePrefix Dosya adı öneki
+ * @param options Migration seçenekleri
+ * @returns Migration sonucu
+ */
+declare function generateMigration<T>(data: T, directoryPath: string, fileNamePrefix?: string, options?: MigrationOptions): Promise<MigrationResult>;
+/**
+ * Belirli bir migration dosyasının bilgilerini alır
+ *
+ * @param migrationsDir Migration dizini
+ * @param fileName Dosya adı (belirtilmezse son migration dosyası)
+ * @returns Migration bilgileri ve verisi
+ */
+declare function getMigration(migrationsDir: string, fileName?: string): Promise<MigrationResult>;
+/**
+ * Tüm migration dosyalarını listeler
+ *
+ * @param migrationsDir Migration dizini
+ * @param filePrefix Dosya adı öneki filtreleme (opsiyonel)
+ * @returns Migration listesi
+ */
+declare function listMigrations(migrationsDir: string, filePrefix?: string): Promise<MigrationInfo[]>;
+/**
+ * Migration'ları ileri uygular (son duruma getirir)
+ *
+ * @param migrationsDir Migration dizini
+ * @param targetTimestamp Hedef zaman damgası (belirtilmezse son migration'a kadar)
+ * @returns Migration sonucu
+ */
+declare function migrationUp(migrationsDir: string, targetTimestamp?: number): Promise<MigrationResult>;
+/**
+ * Migration'ları geri alır (belirtilen noktaya kadar veya bir önceki migration'a)
+ *
+ * @param migrationsDir Migration dizini
+ * @param targetTimestamp Hedef zaman damgası (belirtilmezse bir önceki migration'a döner)
+ * @returns Migration sonucu
+ */
+declare function migrationDown(migrationsDir: string, targetTimestamp?: number): Promise<MigrationResult>;
+
 /**
  * Define a Silgi module, automatically merging defaults with user provided options, installing
  * any hooks that are provided, and calling an optional setup function for full control.
@@ -173,5 +283,5 @@ declare function hasInstalledModule(moduleKey: string, silgi?: SilgiCLI): boolea
 declare const baseHeaderBannerComment: string[];
 declare function processFilePath(src: string): string;
 
-export { MODE_RE, addTemplate, baseHeaderBannerComment, createFunction, createFunctionConfigs, createResolver, defineSilgiModule, defineSilgiPreset, directoryToURL, filterInPlace, formatFunctions, genEnsureSafeVar, getAllEntries, getIpAddress, hasError, hasInstalledModule, hasSilgiModule, hash, ipAddress, isDirectory, isH3, isNitro, isNuxt, normalizeTemplate, parseServices, prettyPath, processFilePath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, serviceParseModule, toArray, tryResolveModule, useLogger, useRequest, useResponse, writeFile };
-export type { FunctionConfig };
+export { MODE_RE, MigrationStatus, addTemplate, baseHeaderBannerComment, createFunction, createFunctionConfigs, createResolver, defineSilgiModule, defineSilgiPreset, directoryToURL, filterInPlace, formatFunctions, genEnsureSafeVar, generateMigration, getAllEntries, getIpAddress, getMigration, hasError, hasInstalledModule, hasSilgiModule, hash, ipAddress, isDirectory, isH3, isNitro, isNuxt, listMigrations, migrationDown, migrationUp, normalizeTemplate, parseServices, prettyPath, processFilePath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, serviceParseModule, toArray, tryResolveModule, useLogger, useRequest, useResponse, writeFile };
+export type { FunctionConfig, JsonPatch, MigrationData, MigrationInfo, MigrationOptions, MigrationResult };

package/dist/kit/index.mjs

@@ -1,18 +1,19 @@
 import { tryUseSilgiCLI, useSilgiCLI, useSilgi } from 'silgi';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import { resolvePath as resolvePath$1 } from 'mlly';
-import fsp from 'node:fs/promises';
+import fsp, { mkdir, readFile, writeFile as writeFile$1 } from 'node:fs/promises';
 import consola, { consola as consola$1 } from 'consola';
-import { relative, resolve, dirname, normalize, isAbsolute, join, parse, basename } from 'pathe';
+import { relative, resolve, dirname, join, normalize, isAbsolute, parse, basename } from 'pathe';
 import { colors } from 'consola/utils';
 import { getProperty } from 'dot-prop';
 import { genString, genObjectFromRaw, genObjectFromValues, genObjectFromRawEntries } from 'knitwork';
 import { hash as hash$1 } from 'ohash';
 import { camelCase } from 'scule';
+import { existsSync, promises } from 'node:fs';
+import * as rfc6902 from 'rfc6902';
 import { defu } from 'defu';
 import { c as checkSilgiCompatibility } from '../cli/compatibility.mjs';
 import { withLeadingSlash } from 'ufo';
-import { existsSync, promises } from 'node:fs';
 import { resolveAlias as resolveAlias$1 } from 'pathe/utils';
 import { hash as hash$2 } from 'silgi/kit';
 import 'semver/functions/satisfies.js';
@@ -238,6 +239,322 @@ function useLogger(tag, options = {}) {
   return tag ? logger.create(options).withTag(tag) : logger;
 }
 
+var MigrationStatus = /* @__PURE__ */ ((MigrationStatus2) => {
+  MigrationStatus2["SUCCESS"] = "success";
+  MigrationStatus2["ERROR"] = "error";
+  MigrationStatus2["SKIPPED"] = "skipped";
+  return MigrationStatus2;
+})(MigrationStatus || {});
+async function generateMigration(data, directoryPath, fileNamePrefix = "data_", options = {}) {
+  const {
+    description,
+    verbose = false,
+    prettyPrint = true,
+    usePatch = true,
+    skipIfNoChanges = true
+  } = options;
+  try {
+    try {
+      if (!existsSync(directoryPath)) {
+        await mkdir(directoryPath, { recursive: true });
+      }
+    } catch (error) {
+      return {
+        success: false,
+        status: "error" /* ERROR */,
+        error: `Dizin olu\u015Fturulamad\u0131: ${error}`
+      };
+    }
+    const latestPath = join(directoryPath, "latest.json");
+    let existingData = null;
+    let hasChanges = true;
+    let patch = [];
+    if (existsSync(latestPath)) {
+      try {
+        const latestContent = await readFile(latestPath, "utf-8");
+        const latestInfo2 = JSON.parse(latestContent);
+        if (latestInfo2?.file) {
+          const existingFilePath = join(directoryPath, latestInfo2.file);
+          if (existsSync(existingFilePath)) {
+            const fileContent2 = await readFile(existingFilePath, "utf-8");
+            try {
+              if (latestInfo2.isPatch) {
+                const result = await migrationUp(directoryPath);
+                if (result.success && result.data) {
+                  existingData = result.data;
+                }
+              } else {
+                existingData = JSON.parse(fileContent2);
+              }
+              if (existingData) {
+                patch = rfc6902.createPatch(existingData, data);
+                hasChanges = patch.length > 0;
+                if (verbose && hasChanges) {
+                  console.warn("De\u011Fi\u015Fiklikler tespit edildi:", patch);
+                }
+              }
+            } catch (err) {
+              console.warn(`Migration verisi i\u015Flenirken hata: ${err}`);
+            }
+          }
+        }
+      } catch (error) {
+        console.warn(`Latest bilgisi okunamad\u0131: ${error}`);
+      }
+    }
+    if (!hasChanges && existingData !== null && skipIfNoChanges) {
+      if (verbose) {
+        console.warn("De\u011Fi\u015Fiklik yok, migration olu\u015Fturulmad\u0131.");
+      }
+      return {
+        success: true,
+        status: "skipped" /* SKIPPED */
+      };
+    }
+    const timestamp = Math.floor(Date.now() / 1e3);
+    const isPatch = usePatch && patch.length > 0 && existingData !== null;
+    const fileName = `${fileNamePrefix}${isPatch ? "patch_" : ""}${timestamp}.json`;
+    const filePath = join(directoryPath, fileName);
+    const fileContent = isPatch ? patch : data;
+    const indent = prettyPrint ? 2 : 0;
+    await writeFile$1(filePath, JSON.stringify(fileContent, null, indent), "utf-8");
+    const latestInfo = {
+      timestamp,
+      file: fileName,
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      description,
+      isPatch
+    };
+    await writeFile$1(latestPath, JSON.stringify(latestInfo, null, indent), "utf-8");
+    if (verbose) {
+      console.warn(`Yeni ${isPatch ? "patch" : "tam veri"} migration olu\u015Fturuldu: ${fileName}`);
+    }
+    return {
+      success: true,
+      status: "success" /* SUCCESS */,
+      filePath,
+      timestamp,
+      isPatch,
+      data: fileContent
+    };
+  } catch (error) {
+    return {
+      success: false,
+      status: "error" /* ERROR */,
+      error: `Migration olu\u015Fturma hatas\u0131: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function getMigration(migrationsDir, fileName) {
+  try {
+    if (!existsSync(migrationsDir)) {
+      return {
+        success: false,
+        status: "error" /* ERROR */,
+        error: `Migration dizini bulunamad\u0131: ${migrationsDir}`
+      };
+    }
+    if (!fileName) {
+      const latestPath = join(migrationsDir, "latest.json");
+      if (!existsSync(latestPath)) {
+        return {
+          success: false,
+          status: "error" /* ERROR */,
+          error: `Latest bilgisi bulunamad\u0131: ${latestPath}`
+        };
+      }
+      const latestContent = await readFile(latestPath, "utf-8");
+      const latestInfo = JSON.parse(latestContent);
+      fileName = latestInfo.file;
+    }
+    const migrationPath = join(migrationsDir, fileName);
+    if (!existsSync(migrationPath)) {
+      return {
+        success: false,
+        status: "error" /* ERROR */,
+        error: `Migration dosyas\u0131 bulunamad\u0131: ${migrationPath}`
+      };
+    }
+    const migrationContent = await readFile(migrationPath, "utf-8");
+    const data = JSON.parse(migrationContent);
+    const isPatch = fileName.includes("_patch_");
+    const timestampMatch = fileName.match(/(\d+)\.json$/);
+    const timestamp = timestampMatch ? Number.parseInt(timestampMatch[1]) : void 0;
+    return {
+      success: true,
+      status: "success" /* SUCCESS */,
+      filePath: migrationPath,
+      timestamp,
+      isPatch,
+      data
+    };
+  } catch (error) {
+    return {
+      success: false,
+      status: "error" /* ERROR */,
+      error: `Migration bilgileri al\u0131n\u0131rken hata: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function listMigrations(migrationsDir, filePrefix) {
+  try {
+    if (!existsSync(migrationsDir)) {
+      return [];
+    }
+    const { readdir } = await import('node:fs/promises');
+    const files = await readdir(migrationsDir);
+    const jsonFiles = files.filter((file) => file.endsWith(".json") && file !== "latest.json");
+    const filteredFiles = filePrefix ? jsonFiles.filter((file) => file.startsWith(filePrefix)) : jsonFiles;
+    return filteredFiles.map((file) => {
+      const isPatch = file.includes("_patch_");
+      const timestampMatch = file.match(/(\d+)\.json$/);
+      const timestamp = timestampMatch ? Number.parseInt(timestampMatch[1]) : 0;
+      return {
+        timestamp,
+        file,
+        created: "",
+        // Dosya içeriğinden çıkarılabilir ancak performans için boş bırakıldı
+        isPatch
+      };
+    }).sort((a, b) => a.timestamp - b.timestamp);
+  } catch (error) {
+    console.error(`Migration listesi al\u0131namad\u0131: ${error instanceof Error ? error.message : String(error)}`);
+    return [];
+  }
+}
+async function migrationUp(migrationsDir, targetTimestamp) {
+  try {
+    const migrations = await listMigrations(migrationsDir);
+    if (migrations.length === 0) {
+      return {
+        success: false,
+        status: "error" /* ERROR */,
+        error: "Migration bulunamad\u0131"
+      };
+    }
+    const targetMigrations = targetTimestamp ? migrations.filter((m) => m.timestamp <= targetTimestamp) : migrations;
+    if (targetMigrations.length === 0) {
+      return {
+        success: false,
+        status: "error" /* ERROR */,
+        error: "Belirtilen zaman damgas\u0131na kadar migration bulunamad\u0131"
+      };
+    }
+    const baseIndex = targetMigrations.findIndex((m) => !m.isPatch);
+    if (baseIndex === -1) {
+      return {
+        success: false,
+        status: "error" /* ERROR */,
+        error: "Tam veri migration bulunamad\u0131"
+      };
+    }
+    const baseMigration = await getMigration(
+      migrationsDir,
+      targetMigrations[baseIndex].file
+    );
+    if (!baseMigration.success || !baseMigration.data) {
+      return {
+        success: false,
+        status: "error" /* ERROR */,
+        error: `Temel veri al\u0131n\u0131rken hata: ${baseMigration.error || "Veri yok"}`
+      };
+    }
+    let currentData;
+    if (Array.isArray(baseMigration.data)) {
+      currentData = [...baseMigration.data];
+    } else {
+      try {
+        currentData = baseMigration.data ? JSON.parse(JSON.stringify(baseMigration.data)) : {};
+      } catch {
+        currentData = baseMigration.data;
+      }
+    }
+    for (let i = baseIndex + 1; i < targetMigrations.length; i++) {
+      if (!targetMigrations[i].isPatch) {
+        const fullMigration = await getMigration(
+          migrationsDir,
+          targetMigrations[i].file
+        );
+        if (fullMigration.success && fullMigration.data) {
+          if (Array.isArray(fullMigration.data)) {
+            currentData = [...fullMigration.data];
+          } else {
+            try {
+              currentData = JSON.parse(JSON.stringify(fullMigration.data));
+            } catch {
+              currentData = fullMigration.data;
+            }
+          }
+        } else {
+          console.warn(`Tam veri migration okunamad\u0131: ${targetMigrations[i].file}`);
+        }
+        continue;
+      }
+      const patchMigration = await getMigration(
+        migrationsDir,
+        targetMigrations[i].file
+      );
+      if (!patchMigration.success || !patchMigration.data) {
+        console.warn(`Patch migration okunamad\u0131: ${targetMigrations[i].file}`);
+        continue;
+      }
+      try {
+        const result = rfc6902.applyPatch(
+          currentData,
+          patchMigration.data
+        );
+        const errors = result.filter((r) => r !== null);
+        if (errors.length > 0) {
+          console.warn(`Patch uygulama uyar\u0131s\u0131 (${targetMigrations[i].file}):`, JSON.stringify(errors));
+        }
+      } catch (patchError) {
+        return {
+          success: false,
+          status: "error" /* ERROR */,
+          error: `Patch uygulama hatas\u0131 (${targetMigrations[i].file}): ${patchError instanceof Error ? patchError.message : String(patchError)}`
+        };
+      }
+    }
+    return {
+      success: true,
+      status: "success" /* SUCCESS */,
+      data: currentData,
+      timestamp: targetMigrations[targetMigrations.length - 1].timestamp
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error || "Undefined error");
+    return {
+      success: false,
+      status: "error" /* ERROR */,
+      error: `Migration uygulama hatas\u0131: ${errorMessage}`
+    };
+  }
+}
+async function migrationDown(migrationsDir, targetTimestamp) {
+  try {
+    if (targetTimestamp === void 0) {
+      const migrations = await listMigrations(migrationsDir);
+      if (migrations.length <= 1) {
+        return {
+          success: false,
+          status: "error" /* ERROR */,
+          error: "Geri al\u0131nabilecek bir \xF6nceki migration bulunamad\u0131"
+        };
+      }
+      const previousMigrations = migrations.slice(0, migrations.length - 1);
+      targetTimestamp = previousMigrations[previousMigrations.length - 1].timestamp;
+    }
+    return await migrationUp(migrationsDir, targetTimestamp);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error || "Undefined error");
+    return {
+      success: false,
+      status: "error" /* ERROR */,
+      error: `Migration geri alma hatas\u0131: ${errorMessage}`
+    };
+  }
+}
+
 function defineSilgiModule(definition) {
   if (definition) {
     return _defineSilgiModule(definition);
@@ -605,4 +922,4 @@ function isValidIp(ip) {
   return false;
 }
 
-export { MODE_RE, addTemplate, baseHeaderBannerComment, createFunction, createFunctionConfigs, createResolver, defineSilgiModule, defineSilgiPreset, directoryToURL, filterInPlace, formatFunctions, genEnsureSafeVar, getAllEntries, getIpAddress, hasError, hasInstalledModule, hasSilgiModule, hash, ipAddress, isDirectory$1 as isDirectory, isH3, isNitro, isNuxt, normalizeTemplate, parseServices, prettyPath, processFilePath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, serviceParseModule, toArray, tryResolveModule, useLogger, useRequest, useResponse, writeFile };
+export { MODE_RE, MigrationStatus, addTemplate, baseHeaderBannerComment, createFunction, createFunctionConfigs, createResolver, defineSilgiModule, defineSilgiPreset, directoryToURL, filterInPlace, formatFunctions, genEnsureSafeVar, generateMigration, getAllEntries, getIpAddress, getMigration, hasError, hasInstalledModule, hasSilgiModule, hash, ipAddress, isDirectory$1 as isDirectory, isH3, isNitro, isNuxt, listMigrations, migrationDown, migrationUp, normalizeTemplate, parseServices, prettyPath, processFilePath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, serviceParseModule, toArray, tryResolveModule, useLogger, useRequest, useResponse, writeFile };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "silgi",
   "type": "module",
-  "version": "0.28.4",
+  "version": "0.28.6",
   "private": false,
   "sideEffects": false,
   "exports": {
@@ -95,6 +95,7 @@
     "pathe": "^2.0.3",
     "picocolors": "^1.1.1",
     "pkg-types": "^2.1.0",
+    "rfc6902": "^5.1.2",
     "scule": "^1.3.0",
     "semver": "^7.7.1",
     "std-env": "^3.9.0",