alepha 0.19.3 → 0.19.4

package/src/cli/vendor/services/VendorService.ts

@@ -50,6 +50,13 @@ export interface VendorDiffResult {
   totalChanges: number;
 }
 
+/**
+ * Shape of the <root>/.alepha/vendor.json lock file.
+ */
+export interface VendorLock {
+  commit: string;
+}
+
 /**
  * Handles syncing and diffing vendored packages from a remote git repository.
  */
@@ -61,29 +68,44 @@ export class VendorService {
   /**
    * Sync vendored packages from a remote repository.
    *
-   * Shallow-clones the remote once, then:
-   * - Without `force`: diffs first. If local modifications exist, aborts
-   *   and returns the diff result without touching local files.
-   * - With `force` (or no changes): removes local copies and replaces them.
+   * Without `force`: checks for local modifications by comparing the local
+   * copy against the last-synced commit (stored in .alepha/vendor.json).
+   * If modifications are found, aborts without touching local files.
+   *
+   * With `force` (or first sync): replaces local copies unconditionally.
    */
   async sync(options: VendorSyncOptions): Promise<VendorSyncResult> {
     const synced: string[] = [];
     const errors: string[] = [];
-    let tmpDir: string | undefined;
 
-    try {
-      tmpDir = await this.cloneRemote(options.remote, options.branch);
+    if (!options.force) {
+      const lock = await this.readLock(options.root);
+
+      if (lock) {
+        let baselineDir: string | undefined;
+        try {
+          baselineDir = await this.cloneAtCommit(options.remote, lock.commit);
+          const diffResult = await this.diffFromClone(
+            options.root,
+            baselineDir,
+            options.packages,
+          );
 
-      if (!options.force) {
-        const diffResult = await this.diffFromClone(
-          options.root,
-          tmpDir,
-          options.packages,
-        );
-        if (diffResult.totalChanges > 0) {
-          return { synced: [], errors: [], aborted: diffResult };
+          if (diffResult.totalChanges > 0) {
+            return { synced: [], errors: [], aborted: diffResult };
+          }
+        } finally {
+          if (baselineDir) {
+            await this.fs.rm(baselineDir, { recursive: true, force: true });
+          }
         }
       }
+    }
+
+    let tmpDir: string | undefined;
+
+    try {
+      tmpDir = await this.cloneRemote(options.remote, options.branch);
 
       for (const pkg of options.packages) {
         const remotePkgDir = this.fs.join(tmpDir, "packages", pkg);
@@ -103,6 +125,9 @@ export class VendorService {
 
         synced.push(pkg);
       }
+
+      const commit = await this.getCommitHash(tmpDir);
+      await this.writeLock(options.root, { commit });
     } finally {
       if (tmpDir) {
         await this.fs.rm(tmpDir, { recursive: true, force: true });
@@ -113,16 +138,21 @@ export class VendorService {
   }
 
   /**
-   * Diff vendored packages against a remote repository.
+   * Diff vendored packages against the last-synced commit.
    *
-   * Shallow-clones the remote, then for each package: recursively compares
-   * files to identify added, modified, and removed files.
+   * Reads the commit hash from .alepha/vendor.json, clones at that commit,
+   * and compares local files to detect modifications since last sync.
    */
   async diff(options: VendorDiffOptions): Promise<VendorDiffResult> {
+    const lock = await this.readLock(options.root);
+    if (!lock) {
+      return { packages: [], totalChanges: 0 };
+    }
+
     let tmpDir: string | undefined;
 
     try {
-      tmpDir = await this.cloneRemote(options.remote, options.branch);
+      tmpDir = await this.cloneAtCommit(options.remote, lock.commit);
       return await this.diffFromClone(options.root, tmpDir, options.packages);
     } finally {
       if (tmpDir) {
@@ -155,24 +185,26 @@ export class VendorService {
       }
 
       if (!remoteExists) {
+        // No baseline = everything local was added by user
         const localFiles = await this.fs.ls(localPkgDir, { recursive: true });
         results.push({
           name: pkg,
-          added: [],
+          added: localFiles,
           modified: [],
-          removed: localFiles,
+          removed: [],
         });
         totalChanges += localFiles.length;
         continue;
       }
 
       if (!localExists) {
+        // Baseline exists but local doesn't = user deleted everything
         const remoteFiles = await this.fs.ls(remotePkgDir, { recursive: true });
         results.push({
           name: pkg,
-          added: remoteFiles,
+          added: [],
           modified: [],
-          removed: [],
+          removed: remoteFiles,
         });
         totalChanges += remoteFiles.length;
         continue;
@@ -205,7 +237,8 @@ export class VendorService {
       if (
         file.endsWith(".spec.ts") ||
         file.endsWith(".spec.tsx") ||
-        file === "LICENSE"
+        file === "LICENSE" ||
+        file === "tsdown.config.ts"
       ) {
         await this.fs.rm(this.fs.join(pkgDir, file), { force: true });
       }
@@ -255,6 +288,69 @@ export class VendorService {
     return tmpDir;
   }
 
+  /**
+   * Clone a remote repository at a specific commit hash.
+   */
+  protected async cloneAtCommit(
+    remote: string,
+    commit: string,
+  ): Promise<string> {
+    const tmpDir = this.fs.join(
+      process.env.TMPDIR || "/tmp",
+      `.alepha-vendor-${Date.now()}`,
+    );
+
+    this.log.debug(`Cloning ${remote}@${commit} into ${tmpDir}`);
+
+    await this.shell.run(`git init ${tmpDir}`, { capture: true });
+    await this.shell.run(`git -C ${tmpDir} remote add origin ${remote}`, {
+      capture: true,
+    });
+    await this.shell.run(`git -C ${tmpDir} fetch --depth 1 origin ${commit}`, {
+      capture: true,
+    });
+    await this.shell.run(`git -C ${tmpDir} checkout FETCH_HEAD`, {
+      capture: true,
+    });
+
+    return tmpDir;
+  }
+
+  /**
+   * Get the HEAD commit hash from a cloned repository.
+   */
+  protected async getCommitHash(repoDir: string): Promise<string> {
+    const hash = await this.shell.run(`git -C ${repoDir} rev-parse HEAD`, {
+      capture: true,
+    });
+    return hash.trim();
+  }
+
+  /**
+   * Read the vendor lock file.
+   */
+  protected async readLock(root: string): Promise<VendorLock | undefined> {
+    const lockPath = this.fs.join(root, ".alepha", "vendor.json");
+    const exists = await this.fs.exists(lockPath);
+    if (!exists) {
+      return undefined;
+    }
+    const content = await this.fs.readFile(lockPath);
+    return JSON.parse(content.toString());
+  }
+
+  /**
+   * Write the vendor lock file.
+   */
+  protected async writeLock(root: string, lock: VendorLock): Promise<void> {
+    const dir = this.fs.join(root, ".alepha");
+    await this.fs.mkdir(dir, { recursive: true });
+    await this.fs.writeFile(
+      this.fs.join(dir, "vendor.json"),
+      JSON.stringify(lock, null, 2),
+    );
+  }
+
   /**
    * Directories to ignore during diff comparisons.
    */
@@ -272,7 +368,8 @@ export class VendorService {
     if (
       filePath.endsWith(".spec.ts") ||
       filePath.endsWith(".spec.tsx") ||
-      filePath === "LICENSE"
+      filePath === "LICENSE" ||
+      filePath === "tsdown.config.ts"
     ) {
       return true;
     }
@@ -307,9 +404,10 @@ export class VendorService {
     const localSet = new Set(filteredLocal);
     const remoteSet = new Set(filteredRemote);
 
+    // Files in baseline but not local = user deleted them
     for (const file of filteredRemote) {
       if (!localSet.has(file)) {
-        added.push(file);
+        removed.push(file);
         continue;
       }
 
@@ -327,9 +425,10 @@ export class VendorService {
       }
     }
 
+    // Files in local but not baseline = user added them
     for (const file of filteredLocal) {
       if (!remoteSet.has(file)) {
-        removed.push(file);
+        added.push(file);
       }
     }
 

package/src/core/__tests__/TypeProvider.spec.ts

@@ -850,12 +850,14 @@ describe("TypeProvider", () => {
         ).toEqual(["valid", "123", "also valid"]);
       });
 
-      it("should reject non-array values", async () => {
+      it("should auto-cast non-array values to single-element array", async () => {
         const alepha = Alepha.create();
         await alepha.start();
         const schema = t.array(t.text());
 
-        expect(() => alepha.codec.validate(schema, "not an array")).toThrow();
+        expect(alepha.codec.validate(schema, "not an array")).toEqual([
+          "not an array",
+        ]);
       });
 
       it("should support array of objects", async () => {

package/src/core/providers/SchemaValidator.ts

@@ -27,7 +27,7 @@ export class SchemaValidator {
     try {
       //
       if (!this.useEval) {
-        return Value.Parse(schema, newValue);
+        return Value.Parse(schema, newValue) as Static<T>;
       }
       return this.getValidator(schema).Parse(newValue) as Static<T>;
     } catch (error: any) {

package/src/core/providers/TypeProvider.ts

@@ -458,18 +458,43 @@ export class TypeProvider {
 
   /**
    * Create a schema for a string enum.
+   *
+   * By default, this creates a real PostgreSQL ENUM type in the database.
+   * Use `{ mode: "text" }` to store as a TEXT column instead.
+   *
+   * @example
+   * ```ts
+   * // PostgreSQL ENUM type (default)
+   * status: t.enum(["pending", "active", "archived"])
+   *
+   * // TEXT column
+   * status: t.enum(["pending", "active", "archived"], { mode: "text" })
+   *
+   * // Shared enum name across tables
+   * status: t.enum(["enabled", "disabled"], { name: "shared_status_enum" })
+   * ```
    */
   public enum<T extends string[]>(
     values: [...T],
-    options?: TTextOptions,
+    options?: TEnumOptions,
   ): TUnsafe<T[number]> {
-    return Type.Unsafe<T[number]>(
+    const { mode, name, ...textOptions } = options ?? {};
+
+    const schema = Type.Unsafe<T[number]>(
       t.text({
         enum: values,
         pattern: values.map((v) => `^${v}$`).join("|"),
-        ...options,
+        ...textOptions,
       }),
     );
+
+    if (mode === "text") {
+      Object.assign(schema, { mode: "text" });
+    } else {
+      Object.assign(schema, { enumName: name });
+    }
+
+    return schema;
   }
 
   // -------------------------------------------------------------------------------------------------------------------
@@ -666,6 +691,24 @@ export class TypeProvider {
 
 export type TextLength = "short" | "regular" | "long" | "rich";
 
+export interface TEnumOptions extends TTextOptions {
+  /**
+   * Storage mode for the enum.
+   *
+   * - `"text"` — stores as a TEXT column in the database.
+   * - When omitted, creates a real PostgreSQL ENUM type.
+   */
+  mode?: "text";
+
+  /**
+   * Custom name for the PostgreSQL ENUM type.
+   *
+   * Use this to share the same enum type across multiple tables.
+   * If not specified, the name is auto-generated from the table and column names.
+   */
+  name?: string;
+}
+
 export interface TTextOptions extends TStringOptions {
   /**
    * Predefined size of the text.

package/src/orm/__tests__/enums.spec.ts

@@ -3,33 +3,33 @@ import { describe, expect, it } from "vitest";
 import { $entity, $repository, DrizzleKitProvider, db } from "../core/index.ts";
 import { AlephaOrmPostgres } from "../postgres/index.ts";
 
-// Test 1: Basic enum using t.enum (should map to TEXT column)
+// Test 1: t.enum with mode: "text" (should map to TEXT column)
 const textEnumEntity = $entity({
   name: "text_enum_test",
   schema: t.object({
     id: db.primaryKey(),
-    status: t.enum(["pending", "active", "archived"]),
-    role: t.enum(["user", "admin", "moderator"]),
+    status: t.enum(["pending", "active", "archived"], { mode: "text" }),
+    role: t.enum(["user", "admin", "moderator"], { mode: "text" }),
   }),
 });
 
-// Test 2: Basic enum using db.enum (should create real PG ENUM type)
+// Test 2: t.enum without mode (should create real PG ENUM type)
 const pgEnumEntity = $entity({
   name: "pg_enum_test",
   schema: t.object({
     id: db.primaryKey(),
-    status: db.enum(["draft", "published", "deleted"]),
-    priority: db.enum(["low", "medium", "high"]),
+    status: t.enum(["draft", "published", "deleted"]),
+    priority: t.enum(["low", "medium", "high"]),
   }),
 });
 
-// Test 3: Mixed t.enum and db.enum in the same table
+// Test 3: Mixed text and pg enum in the same table
 const mixedEnumEntity = $entity({
   name: "mixed_enum_test",
   schema: t.object({
     id: db.primaryKey(),
-    textStatus: t.enum(["open", "closed"]),
-    pgStatus: db.enum(["new", "in_progress", "done"]),
+    textStatus: t.enum(["open", "closed"], { mode: "text" }),
+    pgStatus: t.enum(["new", "in_progress", "done"]),
   }),
 });
 
@@ -38,7 +38,7 @@ const sharedEnumEntity1 = $entity({
   name: "shared_enum_test_1",
   schema: t.object({
     id: db.primaryKey(),
-    status: db.enum(["enabled", "disabled"], { name: "shared_status_enum" }),
+    status: t.enum(["enabled", "disabled"], { name: "shared_status_enum" }),
   }),
 });
 
@@ -46,7 +46,7 @@ const sharedEnumEntity2 = $entity({
   name: "shared_enum_test_2",
   schema: t.object({
     id: db.primaryKey(),
-    status: db.enum(["enabled", "disabled"], { name: "shared_status_enum" }),
+    status: t.enum(["enabled", "disabled"], { name: "shared_status_enum" }),
   }),
 });
 
@@ -55,7 +55,7 @@ const conflictEnumEntity1 = $entity({
   name: "conflict_enum_test_1",
   schema: t.object({
     id: db.primaryKey(),
-    status: db.enum(["a", "b", "c"], { name: "conflict_status_enum" }),
+    status: t.enum(["a", "b", "c"], { name: "conflict_status_enum" }),
   }),
 });
 
@@ -63,12 +63,12 @@ const conflictEnumEntity2 = $entity({
   name: "conflict_enum_test_2",
   schema: t.object({
     id: db.primaryKey(),
-    status: db.enum(["a", "b", "d"], { name: "conflict_status_enum" }), // Different value!
+    status: t.enum(["a", "b", "d"], { name: "conflict_status_enum" }), // Different value!
   }),
 });
 
-describe("enums - t.enum (TEXT column)", () => {
-  it("should create TEXT columns for t.enum fields", async () => {
+describe("enums - t.enum with mode: 'text' (TEXT column)", () => {
+  it("should create TEXT columns for t.enum fields with mode: 'text'", async () => {
     const alepha = Alepha.create().with(AlephaOrmPostgres);
 
     class App {
@@ -87,12 +87,12 @@ describe("enums - t.enum (TEXT column)", () => {
 
     expect(sql).toContainEqual(expect.stringContaining("CREATE TABLE"));
     expect(sql).toContainEqual(expect.stringContaining("text_enum_test"));
-    // t.enum should map to TEXT, not a real ENUM type
+    // mode: "text" should map to TEXT, not a real ENUM type
     expect(sql.some((s) => s.includes('"status" text'))).toBe(true);
     expect(sql.some((s) => s.includes('"role" text'))).toBe(true);
   });
 
-  it("should allow inserting and querying with t.enum values", async () => {
+  it("should allow inserting and querying with text enum values", async () => {
     const alepha = Alepha.create().with(AlephaOrmPostgres);
 
     class App {
@@ -117,8 +117,8 @@ describe("enums - t.enum (TEXT column)", () => {
   });
 });
 
-describe("enums - db.enum (real PG ENUM type)", () => {
-  it("should create real PostgreSQL ENUM types for db.enum fields", async () => {
+describe("enums - t.enum (real PG ENUM type)", () => {
+  it("should create real PostgreSQL ENUM types for t.enum fields", async () => {
     const alepha = Alepha.create().with(AlephaOrmPostgres);
 
     class App {
@@ -137,13 +137,13 @@ describe("enums - db.enum (real PG ENUM type)", () => {
 
     expect(sql).toContainEqual(expect.stringContaining("CREATE TABLE"));
     expect(sql).toContainEqual(expect.stringContaining("pg_enum_test"));
-    // db.enum should create real ENUM types
+    // t.enum without mode should create real ENUM types
     expect(
       sql.some((s) => s.includes("CREATE TYPE") || s.includes("DO $$ BEGIN")),
     ).toBe(true);
   });
 
-  it("should allow inserting and querying with db.enum values", async () => {
+  it("should allow inserting and querying with pg enum values", async () => {
     const alepha = Alepha.create().with(AlephaOrmPostgres);
 
     class App {
@@ -168,7 +168,7 @@ describe("enums - db.enum (real PG ENUM type)", () => {
   });
 });
 
-describe("enums - mixed t.enum and db.enum in same table", () => {
+describe("enums - mixed text and pg enum in same table", () => {
   it("should handle both TEXT and PG ENUM types in the same table", async () => {
     const alepha = Alepha.create().with(AlephaOrmPostgres);
 
@@ -299,13 +299,6 @@ describe("enums - conflict detection with different values", () => {
   it("should throw error when same enum name has different values", async () => {
     const alepha = Alepha.create().with(AlephaOrmPostgres);
 
-    const load = async () => {
-      return alepha.with(() => ({
-        r1: $repository(conflictEnumEntity1),
-        r2: $repository(conflictEnumEntity2),
-      }));
-    };
-
     expect(() =>
       alepha.with(() => ({
         r1: $repository(conflictEnumEntity1),