alepha 0.23.0 → 0.24.0

package/src/orm/__tests__/orm-next-tests.ts

@@ -1,4 +1,4 @@
-import { type Alepha, t } from "alepha";
+import { type Alepha, z } from "alepha";
 import { sql } from "drizzle-orm";
 import { expect } from "vitest";
 import { PG_GENERATED } from "../core/constants/PG_SYMBOLS.ts";
@@ -10,11 +10,11 @@ import { $entity, $repository, db, pgAttr } from "../core/index.ts";
 
 const orderEntity = $entity({
   name: "orders",
-  schema: t.object({
+  schema: z.object({
     id: db.primaryKey(),
-    category: t.text(),
-    amount: t.number(),
-    status: t.text(),
+    category: z.text(),
+    amount: z.number(),
+    status: z.text(),
   }),
 });
 
@@ -25,10 +25,10 @@ const orderEntity = $entity({
 export const testPartialIndex = async (alepha: Alepha) => {
   const entity = $entity({
     name: "items_partial_idx",
-    schema: t.object({
+    schema: z.object({
       id: db.primaryKey(),
-      email: t.text(),
-      active: t.boolean(),
+      email: z.text(),
+      active: z.boolean(),
     }),
     indexes: [
       {
@@ -62,11 +62,11 @@ export const testPartialIndex = async (alepha: Alepha) => {
 export const testPartialCompositeIndex = async (alepha: Alepha) => {
   const entity = $entity({
     name: "items_partial_comp_idx",
-    schema: t.object({
+    schema: z.object({
       id: db.primaryKey(),
-      category: t.text(),
-      name: t.text(),
-      active: t.boolean(),
+      category: z.text(),
+      name: z.text(),
+      active: z.boolean(),
     }),
     indexes: [
       {
@@ -100,18 +100,18 @@ export const testPartialCompositeIndex = async (alepha: Alepha) => {
 export const testExistsSubquery = async (alepha: Alepha) => {
   const parentEntity = $entity({
     name: "parents_exist",
-    schema: t.object({
+    schema: z.object({
       id: db.primaryKey(),
-      name: t.text(),
+      name: z.text(),
     }),
   });
 
   const childEntity = $entity({
     name: "children_exist",
-    schema: t.object({
+    schema: z.object({
       id: db.primaryKey(),
-      parentId: t.integer(),
-      label: t.text(),
+      parentId: z.integer(),
+      label: z.text(),
     }),
   });
 
@@ -268,11 +268,11 @@ export const testAggregateOrderByDotNotation = async (alepha: Alepha) => {
 export const testGeneratedColumnSqlite = async (alepha: Alepha) => {
   const entity = $entity({
     name: "generated_col",
-    schema: t.object({
+    schema: z.object({
       id: db.primaryKey(),
-      firstName: t.text(),
-      lastName: t.text(),
-      fullName: pgAttr(t.text(), PG_GENERATED, {
+      firstName: z.text(),
+      lastName: z.text(),
+      fullName: pgAttr(z.text(), PG_GENERATED, {
         expression: sql`first_name || ' ' || last_name`,
         mode: "virtual",
       }),
@@ -303,11 +303,11 @@ export const testGeneratedColumnSqlite = async (alepha: Alepha) => {
 export const testGeneratedColumnPostgres = async (alepha: Alepha) => {
   const entity = $entity({
     name: "generated_col_pg",
-    schema: t.object({
+    schema: z.object({
       id: db.primaryKey(),
-      firstName: t.text(),
-      lastName: t.text(),
-      fullName: pgAttr(t.text(), PG_GENERATED, {
+      firstName: z.text(),
+      lastName: z.text(),
+      fullName: pgAttr(z.text(), PG_GENERATED, {
         expression: sql`first_name || ' ' || last_name`,
         mode: "stored",
       }),
@@ -338,11 +338,11 @@ export const testGeneratedColumnExcludedFromInsertSchema = async (
 ) => {
   const entity = $entity({
     name: "generated_schema_test",
-    schema: t.object({
+    schema: z.object({
       id: db.primaryKey(),
-      a: t.text(),
-      b: t.text(),
-      computed: pgAttr(t.text(), PG_GENERATED, {
+      a: z.text(),
+      b: z.text(),
+      computed: pgAttr(z.text(), PG_GENERATED, {
         expression: sql`a || b`,
         mode: "virtual",
       }),

package/src/orm/__tests__/orm-showcase-tests.ts

@@ -1,5 +1,5 @@
 import type { Alepha } from "alepha";
-import { t } from "alepha";
+import { z } from "alepha";
 import { expect } from "vitest";
 import { $entity, $repository, db } from "../core/index.ts";
 
@@ -9,21 +9,21 @@ import { $entity, $repository, db } from "../core/index.ts";
 
 const teams = $entity({
   name: "teams",
-  schema: t.object({
+  schema: z.object({
     id: db.primaryKey(),
-    name: t.text(),
-    country: t.text(),
+    name: z.text(),
+    country: z.text(),
   }),
 });
 
 const players = $entity({
   name: "players",
-  schema: t.object({
+  schema: z.object({
     id: db.primaryKey(),
-    teamId: db.ref(t.optional(t.integer()), () => teams.cols.id),
-    name: t.text(),
-    position: t.text(),
-    goals: db.default(t.integer(), 0),
+    teamId: db.ref(z.integer().optional(), () => teams.cols.id),
+    name: z.text(),
+    position: z.text(),
+    goals: db.default(z.integer(), 0),
   }),
 });
 

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

@@ -1,4 +1,4 @@
-import { Alepha, t } from "alepha";
+import { Alepha, z } from "alepha";
 import { describe, expect, it } from "vitest";
 import { DbError } from "../core/errors/DbError.ts";
 import { $entity, $repository, db } from "../core/index.ts";
@@ -10,7 +10,7 @@ describe("primaryKey", () => {
       identity = $repository(
         $entity({
           name: "identity",
-          schema: t.object({
+          schema: z.object({
             id: db.identityPrimaryKey({
               mode: "always",
               minValue: 2147483646,
@@ -38,7 +38,7 @@ describe("primaryKey", () => {
       big = $repository(
         $entity({
           name: "big",
-          schema: t.object({
+          schema: z.object({
             id: db.bigIdentityPrimaryKey({
               mode: "always",
               minValue: 2147483646,
@@ -70,7 +70,7 @@ describe("primaryKey", () => {
       uuid = $repository(
         $entity({
           name: "uuid",
-          schema: t.object({
+          schema: z.object({
             id: db.uuidPrimaryKey(),
           }),
         }),

package/src/orm/__tests__/query-date-encoding-tests.ts

@@ -1,4 +1,4 @@
-import { type Alepha, t } from "alepha";
+import { type Alepha, z } from "alepha";
 import { DateTimeProvider } from "alepha/datetime";
 import { expect } from "vitest";
 import { $entity, $repository, db } from "../core/index.ts";
@@ -10,11 +10,11 @@ import { $entity, $repository, db } from "../core/index.ts";
 export const testDateFiltersWithDayjs = async (alepha: Alepha) => {
   const Entity = $entity({
     name: "events",
-    schema: t.object({
+    schema: z.object({
       id: db.primaryKey(),
-      name: t.text(),
+      name: z.text(),
       eventDate: db.createdAt(),
-      scheduledFor: t.optional(t.datetime()),
+      scheduledFor: z.datetime().optional(),
     }),
   });
 
@@ -118,10 +118,10 @@ export const testDateFiltersWithDayjs = async (alepha: Alepha) => {
 export const testMixedDateFormats = async (alepha: Alepha) => {
   const Entity = $entity({
     name: "tasks",
-    schema: t.object({
+    schema: z.object({
       id: db.primaryKey(),
-      title: t.text(),
-      dueDate: t.optional(t.datetime()),
+      title: z.text(),
+      dueDate: z.datetime().optional(),
     }),
   });
 
@@ -165,11 +165,11 @@ export const testMixedDateFormats = async (alepha: Alepha) => {
 export const testDateComparisonsInComplexQueries = async (alepha: Alepha) => {
   const Entity = $entity({
     name: "appointments",
-    schema: t.object({
+    schema: z.object({
       id: db.primaryKey(),
-      patientName: t.text(),
-      appointmentDate: t.datetime(),
-      status: t.text(),
+      patientName: z.text(),
+      appointmentDate: z.datetime(),
+      status: z.text(),
     }),
   });
 
@@ -238,10 +238,10 @@ export const testDateComparisonsInComplexQueries = async (alepha: Alepha) => {
 export const testNullDateValues = async (alepha: Alepha) => {
   const Entity = $entity({
     name: "projects",
-    schema: t.object({
+    schema: z.object({
       id: db.primaryKey(),
-      name: t.text(),
-      completedAt: t.optional(t.datetime()),
+      name: z.text(),
+      completedAt: z.datetime().optional(),
     }),
   });
 
@@ -283,10 +283,10 @@ export const testNullDateValues = async (alepha: Alepha) => {
 export const testDateEncodingWithNotInArray = async (alepha: Alepha) => {
   const Entity = $entity({
     name: "events",
-    schema: t.object({
+    schema: z.object({
       id: db.primaryKey(),
-      name: t.text(),
-      date: t.datetime(),
+      name: z.text(),
+      date: z.datetime(),
     }),
   });
 

package/src/orm/__tests__/ref-auto-onDelete.spec.ts

@@ -1,4 +1,4 @@
-import { Alepha, t } from "alepha";
+import { Alepha, z } from "alepha";
 import { describe, expect, it } from "vitest";
 import { $entity, $repository, db } from "../core/index.ts";
 import { AlephaOrmPostgres } from "../postgres/index.ts";
@@ -6,32 +6,32 @@ import { AlephaOrmPostgres } from "../postgres/index.ts";
 describe("db.ref - automatic onDelete behavior", () => {
   const categories = $entity({
     name: "categories",
-    schema: t.object({
+    schema: z.object({
       id: db.identityPrimaryKey(),
       __v: db.version(),
-      name: t.text(),
+      name: z.text(),
     }),
   });
 
   const products = $entity({
     name: "products",
-    schema: t.object({
+    schema: z.object({
       id: db.identityPrimaryKey(),
       __v: db.version(),
-      name: t.text(),
+      name: z.text(),
       // Optional reference - should automatically set onDelete: "set null"
-      categoryId: db.ref(t.optional(t.integer()), () => categories.cols.id),
+      categoryId: db.ref(z.integer().optional(), () => categories.cols.id),
     }),
   });
 
   const orders = $entity({
     name: "orders",
-    schema: t.object({
+    schema: z.object({
       id: db.identityPrimaryKey(),
       __v: db.version(),
-      orderNumber: t.text(),
+      orderNumber: z.text(),
       // Required reference - should automatically set onDelete: "cascade"
-      productId: db.ref(t.integer(), () => products.cols.id),
+      productId: db.ref(z.integer(), () => products.cols.id),
     }),
   });
 
@@ -104,22 +104,22 @@ describe("db.ref - automatic onDelete behavior", () => {
     // Test that explicit actions are not overridden by auto behavior
     const customCategories = $entity({
       name: "custom_categories",
-      schema: t.object({
+      schema: z.object({
         id: db.identityPrimaryKey(),
         __v: db.version(),
-        name: t.text(),
+        name: z.text(),
       }),
     });
 
     const customProducts = $entity({
       name: "custom_products",
-      schema: t.object({
+      schema: z.object({
         id: db.identityPrimaryKey(),
         __v: db.version(),
-        name: t.text(),
+        name: z.text(),
         // Optional reference but explicitly set to cascade
         categoryId: db.ref(
-          t.optional(t.integer()),
+          z.integer().optional(),
           () => customCategories.cols.id,
           {
             onDelete: "cascade",

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

@@ -1,15 +1,15 @@
-import { Alepha, t } from "alepha";
+import { Alepha, z } from "alepha";
 import { describe, expect, it } from "vitest";
 import { $entity, $repository, db } from "../core/index.ts";
 import { AlephaOrmPostgres } from "../postgres/index.ts";
 
 const users = $entity({
   name: "users",
-  schema: t.object({
+  schema: z.object({
     id: db.identityPrimaryKey(),
     __v: db.version(),
-    name: t.text(),
-    currentPostId: db.ref(t.optional(t.integer()), () => posts.cols.id, {
+    name: z.text(),
+    currentPostId: db.ref(z.integer().optional(), () => posts.cols.id, {
       onDelete: "set null",
     }),
   }),
@@ -17,13 +17,13 @@ const users = $entity({
 
 const posts = $entity({
   name: "posts",
-  schema: t.object({
+  schema: z.object({
     id: db.identityPrimaryKey(),
     __v: db.version(),
-    userId: db.ref(t.integer(), () => users.cols.id, {
+    userId: db.ref(z.integer(), () => users.cols.id, {
       onDelete: "cascade",
     }),
-    postParentId: db.ref(t.optional(t.integer()), () => posts.cols.id, {
+    postParentId: db.ref(z.integer().optional(), () => posts.cols.id, {
       onDelete: "cascade",
     }),
   }),

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

@@ -1,4 +1,4 @@
-import { Alepha, t } from "alepha";
+import { Alepha, z } from "alepha";
 import { describe, expect, it } from "vitest";
 import {
   $entity,
@@ -28,22 +28,22 @@ describe("SQL Injection Security Tests", () => {
   // Define test entities with various column types
   const users = $entity({
     name: "users",
-    schema: t.object({
+    schema: z.object({
       id: db.primaryKey(),
-      username: t.text(),
-      email: t.text(),
-      age: t.integer(),
-      profile: t.object({
-        bio: t.text(),
-        settings: t.object({
-          theme: t.text(),
-          notifications: t.boolean(),
+      username: z.text(),
+      email: z.text(),
+      age: z.integer(),
+      profile: z.object({
+        bio: z.text(),
+        settings: z.object({
+          theme: z.text(),
+          notifications: z.boolean(),
         }),
       }),
-      tags: t.array(t.text()),
-      metadata: t.object({
-        permissions: t.array(t.text()),
-        lastLogin: t.optional(t.text()),
+      tags: z.array(z.text()),
+      metadata: z.object({
+        permissions: z.array(z.text()),
+        lastLogin: z.text().optional(),
       }),
     }),
   });
@@ -405,7 +405,7 @@ describe("SQL Injection Security Tests", () => {
           // Using parameterized queries should be safe
           const result = await app.users.query(
             (t) => sql`SELECT * FROM ${t} WHERE ${t.username} = ${payload}`,
-            t.pick(users.schema, ["username"]),
+            users.schema.pick({ username: true }),
           );
 
           // Should treat payload as a literal value
@@ -434,7 +434,7 @@ describe("SQL Injection Security Tests", () => {
           const result = await app.users.query(
             (t) =>
               sql`SELECT * FROM ${t} WHERE ${t.username} LIKE ${`%${payload}%`}`,
-            t.pick(users.schema, ["username"]),
+            users.schema.pick({ username: true }),
           );
 
           expect(result).toEqual([]);
@@ -581,7 +581,7 @@ describe("SQL Injection Security Tests", () => {
         for (const payload of sqlInjectionPayloads) {
           const result = await app.users.query(
             (t) => sql`SELECT * FROM ${t} WHERE ${t.username} = ${payload}`,
-            t.pick(users.schema, ["username"]),
+            users.schema.pick({ username: true }),
           );
 
           expect(result).toEqual([]);

package/src/orm/__tests__/string-operators-tests.ts

@@ -1,16 +1,16 @@
-import { type Alepha, t } from "alepha";
+import { type Alepha, z } from "alepha";
 import { expect } from "vitest";
 import { $entity, $repository, db } from "../core/index.ts";
 
 const User = $entity({
   name: "users",
-  schema: t.object({
+  schema: z.object({
     id: db.primaryKey(),
     createdAt: db.createdAt(),
     updatedAt: db.updatedAt(),
-    name: t.text(),
-    email: t.text(),
-    bio: t.optional(t.text()),
+    name: z.text(),
+    email: z.text(),
+    bio: z.text().optional(),
   }),
 });
 

package/src/orm/__tests__/timestamps-tests.ts

@@ -1,4 +1,4 @@
-import { type Alepha, t } from "alepha";
+import { type Alepha, z } from "alepha";
 import { expect } from "vitest";
 import { $entity, $repository } from "../core/index.ts";
 import { db } from "../core/providers/DatabaseTypeProvider.ts";
@@ -14,11 +14,11 @@ const parseDate = (dateValue: any): Date => {
 
 const articleEntity = $entity({
   name: "articles",
-  schema: t.object({
+  schema: z.object({
     id: db.primaryKey(),
-    title: t.string(),
-    content: t.text(),
-    status: t.string(),
+    title: z.string(),
+    content: z.text(),
+    status: z.string(),
     createdAt: db.createdAt(),
     updatedAt: db.updatedAt(),
   }),
@@ -34,13 +34,13 @@ const articleEntity = $entity({
 
 const userActivityEntity = $entity({
   name: "user_activities",
-  schema: t.object({
+  schema: z.object({
     id: db.primaryKey(),
-    userId: t.integer(),
-    action: t.string(),
-    metadata: t.optional(t.record(t.string(), t.any())),
+    userId: z.integer(),
+    action: z.string(),
+    metadata: z.record(z.string(), z.any()).optional(),
     createdAt: db.createdAt(),
-    updatedAt: t.optional(db.updatedAt()),
+    updatedAt: db.updatedAt().optional(),
   }),
 });
 
@@ -271,12 +271,12 @@ export const testTimestampIndexes = async (alepha: Alepha) => {
 export const testTimestampFormats = async (alepha: Alepha) => {
   const eventEntity = $entity({
     name: "events",
-    schema: t.object({
+    schema: z.object({
       id: db.primaryKey(),
-      name: t.string(),
+      name: z.string(),
       startTime: db.createdAt(),
-      endTime: t.optional(db.updatedAt()),
-      scheduledAt: t.string(),
+      endTime: db.updatedAt().optional(),
+      scheduledAt: z.string(),
     }),
   });
 

package/src/orm/__tests__/validation-tests.ts

@@ -1,16 +1,16 @@
-import { type Alepha, t } from "alepha";
+import { type Alepha, z } from "alepha";
 import { expect } from "vitest";
 import { $entity, $repository, db } from "../core/index.ts";
 
 const TestEntity = $entity({
   name: "test_validation",
-  schema: t.object({
+  schema: z.object({
     id: db.primaryKey(),
     createdAt: db.createdAt(),
     updatedAt: db.updatedAt(),
-    name: t.text(),
-    age: t.number(),
-    status: t.text(),
+    name: z.text(),
+    age: z.number(),
+    status: z.text(),
   }),
 });
 

package/src/orm/core/__tests__/BunSqliteProvider.bun.spec.ts

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, it } from "bun:test";
-import { Alepha, t } from "alepha";
+import { Alepha, z } from "alepha";
 import { $entity, $repository, DatabaseProvider, db } from "../index.ts";
 import {
   BunSqliteProvider,
@@ -10,18 +10,18 @@ import {
 
 const users = $entity({
   name: "users",
-  schema: t.object({
-    id: db.primaryKey(t.integer()),
-    name: t.text(),
+  schema: z.object({
+    id: db.primaryKey(z.integer()),
+    name: z.text(),
   }),
 });
 
 const posts = $entity({
   name: "posts",
-  schema: t.object({
-    id: db.primaryKey(t.bigint()),
-    title: t.text(),
-    body: t.optional(t.text()),
+  schema: z.object({
+    id: db.primaryKey(z.bigint()),
+    title: z.text(),
+    body: z.text().optional(),
   }),
 });
 

package/src/orm/core/constants/PG_SYMBOLS.ts

@@ -37,7 +37,7 @@ export type PgSymbols = {
   [PG_REF]: PgRefOptions;
   [PG_ENUM]: PgEnumOptions;
   [PG_GENERATED]: PgGeneratedOptions;
-  [PG_ORGANIZATION]: {};
+  [PG_ORGANIZATION]: PgOrganizationOptions;
 
   /**
    * @deprecated Use `PG_IDENTITY` instead.
@@ -47,6 +47,18 @@ export type PgSymbols = {
 
 export type PgSymbolKeys = keyof PgSymbols;
 
+export interface PgOrganizationOptions {
+  /**
+   * Fail-closed tenant scoping. When `true`, the repository (a) refuses any
+   * read/write with no resolved tenant instead of falling through to an
+   * unfiltered "see/write everything" query, and (b) drops the
+   * `OR organizationId IS NULL` "global row" escape — a scoped tenant never
+   * sees NULL/global rows. Use for security-sensitive tables. Defaults to
+   * `false` (the historic fail-open semantics).
+   */
+  strict?: boolean;
+}
+
 export type PgIdentityOptions = {
   mode: "always" | "byDefault";
 } & PgSequenceOptions & {

package/src/orm/core/entities/alephaSequences.ts

@@ -1,4 +1,4 @@
-import { type Static, t } from "alepha";
+import { type Static, z } from "alepha";
 import { $entity } from "../primitives/$entity.ts";
 import { db } from "../providers/DatabaseTypeProvider.ts";
 
@@ -16,25 +16,25 @@ import { db } from "../providers/DatabaseTypeProvider.ts";
  */
 export const alephaSequences = $entity({
   name: "alepha_sequences",
-  schema: t.object({
-    id: db.primaryKey(t.uuid()),
+  schema: z.object({
+    id: db.primaryKey(z.uuid()),
 
     createdAt: db.createdAt(),
     updatedAt: db.updatedAt(),
 
-    name: t.text({
+    name: z.text({
       description: "Sequence primitive name (from $sequence's property key).",
     }),
 
-    scope: t.text({
+    scope: z.text({
       description:
         "Caller-provided sub-scope. Defaults to 'default' for the unscoped form.",
       default: "default",
     }),
 
-    value: t.integer({
-      description: "Current counter value, advanced atomically on each call.",
-    }),
+    value: z
+      .integer()
+      .describe("Current counter value, advanced atomically on each call."),
   }),
   indexes: [{ columns: ["name", "scope"], unique: true }],
 });