alepha 0.15.0 → 0.15.1

package/src/cli/services/ProjectScaffolder.ts

@@ -8,8 +8,8 @@ import { biomeJson } from "../assets/biomeJson.ts";
 import { type ClaudeMdOptions, claudeMd } from "../assets/claudeMd.ts";
 import { dummySpecTs } from "../assets/dummySpecTs.ts";
 import { editorconfig } from "../assets/editorconfig.ts";
-import { indexHtml } from "../assets/indexHtml.ts";
 import { mainBrowserTs } from "../assets/mainBrowserTs.ts";
+import { mainCss } from "../assets/mainCss.ts";
 import { mainServerTs } from "../assets/mainServerTs.ts";
 import { tsconfigJson } from "../assets/tsconfigJson.ts";
 import { webAppRouterTs } from "../assets/webAppRouterTs.ts";
@@ -54,6 +54,7 @@ export class ProjectScaffolder {
   public async ensureConfig(
     root: string,
     opts: {
+      force?: boolean;
       packageJson?: boolean | DependencyModes;
       tsconfigJson?: boolean;
       indexHtml?: boolean;
@@ -63,6 +64,7 @@ export class ProjectScaffolder {
     },
   ): Promise<void> {
     const tasks: Promise<void>[] = [];
+    const force = opts.force ?? false;
 
     if (opts.packageJson) {
       tasks.push(
@@ -75,22 +77,24 @@ export class ProjectScaffolder {
       );
     }
     if (opts.tsconfigJson) {
-      tasks.push(this.ensureTsConfig(root));
+      tasks.push(this.ensureTsConfig(root, { force }));
     }
     if (opts.indexHtml) {
-      tasks.push(this.ensureReactProject(root));
+      tasks.push(this.ensureReactProject(root, { force }));
     }
     if (opts.biomeJson) {
-      tasks.push(this.ensureBiomeConfig(root));
+      tasks.push(this.ensureBiomeConfig(root, { force }));
     }
     if (opts.editorconfig) {
-      tasks.push(this.ensureEditorConfig(root));
+      tasks.push(this.ensureEditorConfig(root, { force }));
     }
     if (opts.claudeMd) {
       tasks.push(
         this.ensureClaudeMd(
           root,
-          typeof opts.claudeMd === "boolean" ? {} : opts.claudeMd,
+          typeof opts.claudeMd === "boolean"
+            ? { force }
+            : { ...opts.claudeMd, force },
         ),
       );
     }
@@ -102,30 +106,39 @@ export class ProjectScaffolder {
   // Config Files
   // ===========================================
 
-  public async ensureTsConfig(root: string): Promise<void> {
+  public async ensureTsConfig(
+    root: string,
+    opts: { force?: boolean } = {},
+  ): Promise<void> {
     // Check if tsconfig.json exists in current or parent directories
-    if (await this.existsInParents(root, "tsconfig.json")) {
+    if (!opts.force && (await this.existsInParents(root, "tsconfig.json"))) {
       return;
     }
-    await this.fs.writeFile(this.fs.join(root, "tsconfig.json"), tsconfigJson);
+    await this.fs.writeFile(
+      this.fs.join(root, "tsconfig.json"),
+      tsconfigJson(),
+    );
   }
 
-  public async ensureBiomeConfig(root: string): Promise<void> {
-    await this.ensureFileIfNotExists(root, "biome.json", biomeJson);
+  public async ensureBiomeConfig(
+    root: string,
+    opts: { force?: boolean } = {},
+  ): Promise<void> {
+    await this.ensureFile(root, "biome.json", biomeJson(), opts.force);
   }
 
-  public async ensureEditorConfig(root: string): Promise<void> {
-    await this.ensureFileIfNotExists(root, ".editorconfig", editorconfig);
+  public async ensureEditorConfig(
+    root: string,
+    opts: { force?: boolean } = {},
+  ): Promise<void> {
+    await this.ensureFile(root, ".editorconfig", editorconfig(), opts.force);
   }
 
   public async ensureClaudeMd(
     root: string,
-    options: ClaudeMdOptions = {},
+    options: ClaudeMdOptions & { force?: boolean } = {},
   ): Promise<void> {
-    const path = this.fs.join(root, "CLAUDE.md");
-    if (!(await this.fs.exists(path))) {
-      await this.fs.writeFile(path, claudeMd(options));
-    }
+    await this.ensureFile(root, "CLAUDE.md", claudeMd(options), options.force);
   }
 
   // ===========================================
@@ -140,11 +153,14 @@ export class ProjectScaffolder {
    * - src/api/index.ts (API module)
    * - src/api/controllers/HelloController.ts (example controller)
    */
-  public async ensureApiProject(root: string): Promise<void> {
+  public async ensureApiProject(
+    root: string,
+    opts: { force?: boolean } = {},
+  ): Promise<void> {
     const srcDir = this.fs.join(root, "src");
 
-    // Don't overwrite existing content
-    if (await this.fs.exists(srcDir)) {
+    // Don't overwrite existing content unless force is set
+    if (!opts.force && (await this.fs.exists(srcDir))) {
       const files = await this.fs.ls(srcDir);
       if (files.length > 0) return;
     }
@@ -157,17 +173,18 @@ export class ProjectScaffolder {
     });
 
     // Create files
-    await this.fs.writeFile(
-      this.fs.join(srcDir, "main.server.ts"),
-      mainServerTs(),
-    );
-    await this.fs.writeFile(
-      this.fs.join(srcDir, "api/index.ts"),
+    await this.ensureFile(srcDir, "main.server.ts", mainServerTs(), opts.force);
+    await this.ensureFile(
+      srcDir,
+      "api/index.ts",
       apiIndexTs({ appName }),
+      opts.force,
     );
-    await this.fs.writeFile(
-      this.fs.join(srcDir, "api/controllers/HelloController.ts"),
+    await this.ensureFile(
+      srcDir,
+      "api/controllers/HelloController.ts",
       apiHelloControllerTs(),
+      opts.force,
     );
   }
 
@@ -179,16 +196,14 @@ export class ProjectScaffolder {
    * Ensure full React project structure exists.
    *
    * Creates:
-   * - index.html
    * - src/main.server.ts, src/main.browser.ts
    * - src/api/index.ts, src/api/controllers/HelloController.ts
    * - src/web/index.ts, src/web/AppRouter.ts, src/web/components/Hello.tsx
    */
-  public async ensureReactProject(root: string): Promise<void> {
-    if (await this.fs.exists(this.fs.join(root, "index.html"))) {
-      return;
-    }
-
+  public async ensureReactProject(
+    root: string,
+    opts: { force?: boolean } = {},
+  ): Promise<void> {
     const appName = this.getAppName(root);
 
     // Create directories
@@ -199,49 +214,53 @@ export class ProjectScaffolder {
       recursive: true,
     });
 
-    // index.html
-    await this.fs.writeFile(
-      this.fs.join(root, "index.html"),
-      indexHtml("src/main.browser.ts"),
-    );
+    // src/main.css
+    await this.ensureFile(root, "src/main.css", mainCss(), opts.force);
 
     // API structure
-    await this.ensureFileIfNotExists(
+    await this.ensureFile(
       root,
       "src/api/index.ts",
       apiIndexTs({ appName }),
+      opts.force,
     );
-    await this.ensureFileIfNotExists(
+    await this.ensureFile(
       root,
       "src/api/controllers/HelloController.ts",
       apiHelloControllerTs(),
+      opts.force,
     );
-    await this.ensureFileIfNotExists(
+    await this.ensureFile(
       root,
       "src/main.server.ts",
       mainServerTs({ react: true }),
+      opts.force,
     );
 
     // Web structure
-    await this.ensureFileIfNotExists(
+    await this.ensureFile(
       root,
       "src/web/index.ts",
       webIndexTs({ appName }),
+      opts.force,
     );
-    await this.ensureFileIfNotExists(
+    await this.ensureFile(
       root,
       "src/web/AppRouter.ts",
       webAppRouterTs(),
+      opts.force,
     );
-    await this.ensureFileIfNotExists(
+    await this.ensureFile(
       root,
       "src/web/components/Hello.tsx",
       webHelloComponentTsx(),
+      opts.force,
     );
-    await this.ensureFileIfNotExists(
+    await this.ensureFile(
       root,
       "src/main.browser.ts",
       mainBrowserTs(),
+      opts.force,
     );
   }
 
@@ -272,13 +291,17 @@ export class ProjectScaffolder {
   // Helpers
   // ===========================================
 
-  protected async ensureFileIfNotExists(
+  /**
+   * Write a file, optionally overriding if it exists.
+   */
+  protected async ensureFile(
     root: string,
     relativePath: string,
     content: string,
+    force?: boolean,
   ): Promise<void> {
     const fullPath = this.fs.join(root, relativePath);
-    if (!(await this.fs.exists(fullPath))) {
+    if (force || !(await this.fs.exists(fullPath))) {
       await this.fs.writeFile(fullPath, content);
     }
   }

package/src/core/Alepha.ts

@@ -165,13 +165,6 @@ export class Alepha {
         ...state.env,
         ...process.env,
       };
-
-      // remove empty env variables
-      for (const key in state.env) {
-        if (state.env[key] === "") {
-          delete (state.env as any)[key];
-        }
-      }
     }
 
     // force production mode when building with vite
@@ -765,8 +758,9 @@ export class Alepha {
       }
 
       if (this.started) {
+        const mod = (service as WithModule)[MODULE]?.name;
         throw new ContainerLockedError(
-          `Container is locked. No more services can be added. ${parent?.name} -> ${service.name}`,
+          `Container is locked. No more services can be added. Attempted to inject '${service.name}' from '${parent?.name}'. ${mod ? `Maybe register module '${mod}' in Alepha.` : ""}`,
         );
       }
     }

package/src/core/primitives/$module.ts

@@ -4,6 +4,7 @@ import { MODULE } from "../constants/MODULE.ts";
 import { AlephaError } from "../errors/AlephaError.ts";
 import type { PrimitiveFactoryLike } from "../helpers/primitive.ts";
 import type { Service } from "../interfaces/Service.ts";
+import type { Atom } from "./$atom.ts";
 
 /**
  * Wrap Services and Primitives into a Module.
@@ -69,6 +70,12 @@ export const $module = <T extends object = {}>(
     options = options;
 
     register(alepha: Alepha): void {
+      if (options.atoms) {
+        for (const atom of options.atoms) {
+          alepha.store.register(atom);
+        }
+      }
+
       if (typeof options.register === "function") {
         options.register(alepha);
         return;
@@ -134,6 +141,11 @@ export interface ModulePrimitiveOptions {
    * Again, if you declare 'register', you must handle the registration of ALL services manually.
    */
   register?: (alepha: Alepha) => void;
+
+  /**
+   * List of atoms to register in the module.
+   */
+  atoms?: Array<Atom<any>>;
 }
 
 /**

package/src/core/providers/KeylessJsonSchemaCodec.spec.ts

@@ -1,5 +1,6 @@
 import { Alepha, t } from "alepha";
 import { describe, test } from "vitest";
+import { KeylessJsonSchemaCodec } from "./KeylessJsonSchemaCodec.ts";
 
 describe("KeylessJsonSchemaCodec", () => {
   describe("Basic types", () => {
@@ -618,4 +619,260 @@ describe("KeylessJsonSchemaCodec", () => {
       expect(keylessSize).toBeLessThan(jsonSize);
     });
   });
+
+  describe("Safe Mode (Interpreted)", () => {
+    test("should work correctly in safe mode", async ({ expect }) => {
+      const alepha = Alepha.create();
+      const codec = alepha.inject(KeylessJsonSchemaCodec);
+
+      // Force safe mode (no Function compilation)
+      codec.configure({ useFunctionCompilation: false });
+
+      const schema = t.object({
+        name: t.text(),
+        age: t.integer(),
+        active: t.boolean(),
+      });
+
+      const data = {
+        name: "Alice",
+        age: 30,
+        active: true,
+      };
+
+      const encoded = codec.encodeToString(schema, data);
+      expect(encoded).toBe('["Alice",30,true]');
+
+      const decoded = codec.decode(schema, encoded);
+      expect(decoded).toEqual(data);
+    });
+
+    test("should handle nested objects in safe mode", async ({ expect }) => {
+      const alepha = Alepha.create();
+      const codec = alepha.inject(KeylessJsonSchemaCodec);
+
+      codec.configure({ useFunctionCompilation: false });
+
+      const schema = t.object({
+        user: t.object({
+          name: t.text(),
+          profile: t.object({
+            bio: t.text(),
+            age: t.integer(),
+          }),
+        }),
+      });
+
+      const data = {
+        user: {
+          name: "Alice",
+          profile: {
+            bio: "Developer",
+            age: 30,
+          },
+        },
+      };
+
+      const encoded = codec.encodeToString(schema, data);
+      expect(encoded).toBe('[["Alice",["Developer",30]]]');
+
+      const decoded = codec.decode(schema, encoded);
+      expect(decoded).toEqual(data);
+    });
+
+    test("should handle arrays of objects in safe mode", async ({ expect }) => {
+      const alepha = Alepha.create();
+      const codec = alepha.inject(KeylessJsonSchemaCodec);
+
+      codec.configure({ useFunctionCompilation: false });
+
+      const schema = t.object({
+        users: t.array(
+          t.object({
+            name: t.text(),
+            age: t.integer(),
+          }),
+        ),
+      });
+
+      const data = {
+        users: [
+          { name: "Alice", age: 30 },
+          { name: "Bob", age: 25 },
+        ],
+      };
+
+      const encoded = codec.encodeToString(schema, data);
+      const decoded = codec.decode(schema, encoded);
+      expect(decoded).toEqual(data);
+    });
+
+    test("should handle optional fields in safe mode", async ({ expect }) => {
+      const alepha = Alepha.create();
+      const codec = alepha.inject(KeylessJsonSchemaCodec);
+
+      codec.configure({ useFunctionCompilation: false });
+
+      const schema = t.object({
+        name: t.text(),
+        bio: t.optional(t.text()),
+      });
+
+      // With optional field
+      const dataWithBio = { name: "Alice", bio: "Developer" };
+      const encodedWith = codec.encodeToString(schema, dataWithBio);
+      const decodedWith = codec.decode(schema, encodedWith);
+      expect(decodedWith).toEqual(dataWithBio);
+
+      // Without optional field
+      const dataWithoutBio = { name: "Bob" };
+      const encodedWithout = codec.encodeToString(schema, dataWithoutBio);
+      const decodedWithout = codec.decode<{ name: string; bio?: string }>(
+        schema,
+        encodedWithout,
+      );
+      expect(decodedWithout.name).toBe("Bob");
+      expect(decodedWithout.bio).toBeUndefined();
+    });
+
+    test("should handle nullable fields in safe mode", async ({ expect }) => {
+      const alepha = Alepha.create();
+      const codec = alepha.inject(KeylessJsonSchemaCodec);
+
+      codec.configure({ useFunctionCompilation: false });
+
+      const schema = t.object({
+        name: t.text(),
+        deletedAt: t.nullable(t.datetime()),
+      });
+
+      // With null value
+      const dataNull = { name: "Alice", deletedAt: null };
+      const encodedNull = codec.encodeToString(schema, dataNull);
+      const decodedNull = codec.decode<{
+        name: string;
+        deletedAt: string | null;
+      }>(schema, encodedNull);
+      expect(decodedNull.deletedAt).toBeNull();
+
+      // With non-null value
+      const dataValue = { name: "Bob", deletedAt: "2024-01-15T10:00:00Z" };
+      const encodedValue = codec.encodeToString(schema, dataValue);
+      const decodedValue = codec.decode(schema, encodedValue);
+      expect(decodedValue).toEqual(dataValue);
+    });
+  });
+
+  describe("Compiled Mode (Function)", () => {
+    test("should work correctly in compiled mode", async ({ expect }) => {
+      const alepha = Alepha.create();
+      const codec = alepha.inject(KeylessJsonSchemaCodec);
+
+      // Force compiled mode
+      codec.configure({ useFunctionCompilation: true });
+
+      const schema = t.object({
+        name: t.text(),
+        age: t.integer(),
+        active: t.boolean(),
+      });
+
+      const data = {
+        name: "Alice",
+        age: 30,
+        active: true,
+      };
+
+      const encoded = codec.encodeToString(schema, data);
+      expect(encoded).toBe('["Alice",30,true]');
+
+      const decoded = codec.decode(schema, encoded);
+      expect(decoded).toEqual(data);
+    });
+
+    test("should produce same results as safe mode", async ({ expect }) => {
+      const alepha = Alepha.create();
+
+      const codecSafe = alepha.inject(KeylessJsonSchemaCodec);
+      codecSafe.configure({ useFunctionCompilation: false });
+
+      // Create a second Alepha instance for the compiled codec
+      const alepha2 = Alepha.create();
+      const codecCompiled = alepha2.inject(KeylessJsonSchemaCodec);
+      codecCompiled.configure({ useFunctionCompilation: true });
+
+      const schema = t.object({
+        user: t.object({
+          name: t.text(),
+          age: t.integer(),
+        }),
+        tags: t.array(t.text()),
+        active: t.boolean(),
+      });
+
+      const data = {
+        user: { name: "Alice", age: 30 },
+        tags: ["dev", "typescript"],
+        active: true,
+      };
+
+      const encodedSafe = codecSafe.encodeToString(schema, data);
+      const encodedCompiled = codecCompiled.encodeToString(schema, data);
+
+      // Both modes should produce the same output
+      expect(encodedSafe).toBe(encodedCompiled);
+
+      const decodedSafe = codecSafe.decode(schema, encodedSafe);
+      const decodedCompiled = codecCompiled.decode(schema, encodedCompiled);
+
+      // Both modes should decode to the same result
+      expect(decodedSafe).toEqual(data);
+      expect(decodedCompiled).toEqual(data);
+    });
+  });
+
+  describe("Configuration", () => {
+    test("should allow configuring options", async ({ expect }) => {
+      const alepha = Alepha.create();
+      const codec = alepha.inject(KeylessJsonSchemaCodec);
+
+      // Configure all options
+      codec.configure({
+        useFunctionCompilation: false,
+        maxArrayLength: 100,
+        maxStringLength: 1000,
+        maxDepth: 10,
+      });
+
+      // Test that configuration works by encoding/decoding
+      const schema = t.object({ name: t.text() });
+      const data = { name: "test" };
+
+      const encoded = codec.encodeToString(schema, data);
+      const decoded = codec.decode(schema, encoded);
+
+      expect(decoded).toEqual(data);
+    });
+
+    test("should clear cache when compilation mode changes", async ({
+      expect,
+    }) => {
+      const alepha = Alepha.create();
+      const codec = alepha.inject(KeylessJsonSchemaCodec);
+
+      const schema = t.object({ name: t.text() });
+      const data = { name: "test" };
+
+      // Use compiled mode first
+      codec.configure({ useFunctionCompilation: true });
+      const encoded1 = codec.encodeToString(schema, data);
+
+      // Switch to safe mode (cache should be cleared)
+      codec.configure({ useFunctionCompilation: false });
+      const encoded2 = codec.encodeToString(schema, data);
+
+      // Both should produce the same result
+      expect(encoded1).toBe(encoded2);
+    });
+  });
 });