alepha 0.22.0 → 0.24.0

package/src/orm/core/helpers/pgAttr.ts

@@ -8,11 +8,11 @@ import type { PgSymbolKeys, PgSymbols } from "../constants/PG_SYMBOLS.ts";
  *
  * @example
  * ```ts
- * import { t } from "alepha";
+ * import { z } from "alepha";
  * import { PG_UPDATED_AT } from "../constants/PG_SYMBOLS";
  *
  * export const updatedAtSchema = pgAttr(
- *   t.datetime(), PG_UPDATED_AT,
+ *   z.datetime(), PG_UPDATED_AT,
  * );
  * ```
  */
@@ -34,8 +34,8 @@ export const getAttrFields = (
 ): PgAttrField[] => {
   const fields: Array<PgAttrField> = [];
 
-  for (const key of Object.keys(schema.properties)) {
-    const value = schema.properties[key];
+  for (const key of Object.keys(schema.shape)) {
+    const value = schema.shape[key];
     if (name in value) {
       fields.push({
         type: value as TSchema,

package/src/orm/core/primitives/$entity.ts

@@ -13,15 +13,15 @@ import { type TObjectUpdate, updateSchema } from "../schemas/updateSchema.ts";
  *
  * @example
  * ```ts
- * import { t } from "alepha";
+ * import { z } from "alepha";
  * import { $entity } from "alepha/orm";
  *
  * const userEntity = $entity({
  *   name: "users",
- *   schema: t.object({
+ *   schema: z.object({
  *     id: pg.primaryKey(),
- *     name: t.text(),
- *     email: t.email(),
+ *     name: z.text(),
+ *     email: z.email(),
  *   }),
  * });
  * ```
@@ -243,12 +243,16 @@ export class EntityPrimitive<T extends TObject = TObject> {
     return this.options.schema;
   }
 
+  protected _insertSchema?: TObjectInsert<T>;
   get insertSchema(): TObjectInsert<T> {
-    return insertSchema(this.options.schema);
+    this._insertSchema ??= insertSchema(this.options.schema);
+    return this._insertSchema;
   }
 
+  protected _updateSchema?: TObjectUpdate<T>;
   get updateSchema(): TObjectUpdate<T> {
-    return updateSchema(this.options.schema);
+    this._updateSchema ??= updateSchema(this.options.schema);
+    return this._updateSchema;
   }
 }
 

package/src/orm/core/providers/DatabaseTypeProvider.ts

@@ -7,12 +7,11 @@ import {
   type TNumber,
   type TNumberOptions,
   type TObject,
-  type TObjectOptions,
   type TPage,
   type TSchema,
   type TString,
   type TStringOptions,
-  t,
+  z,
 } from "alepha";
 import type { UpdateDeleteAction } from "drizzle-orm/pg-core/foreign-keys";
 import {
@@ -39,24 +38,18 @@ export class DatabaseTypeProvider {
   /**
    * Creates a primary key with an identity column.
    */
-  public readonly identityPrimaryKey = (
-    identity?: PgIdentityOptions,
-    options?: TNumberOptions,
-  ) =>
+  public readonly identityPrimaryKey = (identity?: PgIdentityOptions) =>
     pgAttr(
-      pgAttr(pgAttr(t.integer(options), PG_PRIMARY_KEY), PG_IDENTITY, identity),
+      pgAttr(pgAttr(z.integer(), PG_PRIMARY_KEY), PG_IDENTITY, identity),
       PG_DEFAULT,
     );
 
   /**
    * Creates a primary key with a big identity column. (default)
    */
-  public readonly bigIdentityPrimaryKey = (
-    identity?: PgIdentityOptions,
-    options?: TNumberOptions,
-  ) =>
+  public readonly bigIdentityPrimaryKey = (identity?: PgIdentityOptions) =>
     pgAttr(
-      pgAttr(pgAttr(t.int64(options), PG_PRIMARY_KEY), PG_IDENTITY, identity),
+      pgAttr(pgAttr(z.int64(), PG_PRIMARY_KEY), PG_IDENTITY, identity),
       PG_DEFAULT,
     );
 
@@ -64,7 +57,7 @@ export class DatabaseTypeProvider {
    * Creates a primary key with a UUID column.
    */
   public readonly uuidPrimaryKey = () =>
-    pgAttr(pgAttr(t.uuid(), PG_PRIMARY_KEY), PG_DEFAULT);
+    pgAttr(pgAttr(z.uuid(), PG_PRIMARY_KEY), PG_DEFAULT);
 
   /**
    * Creates a primary key for a given type. Supports:
@@ -94,42 +87,30 @@ export class DatabaseTypeProvider {
   ): PgAttr<PgAttr<TBigInt, PgPrimaryKey>, PgDefault>;
   public primaryKey(
     type?: TSchema,
-    options?: TNumberOptions | TStringOptions,
+    _options?: TNumberOptions | TStringOptions,
     identity?: PgIdentityOptions,
   ): PgAttr<PgAttr<TSchema, PgPrimaryKey>, PgDefault> {
-    if (!type || t.schema.isInteger(type)) {
+    if (!type || z.schema.isInteger(type)) {
       return pgAttr(
-        pgAttr(
-          pgAttr(t.integer(options), PG_PRIMARY_KEY),
-          PG_IDENTITY,
-          identity,
-        ),
+        pgAttr(pgAttr(z.integer(), PG_PRIMARY_KEY), PG_IDENTITY, identity),
         PG_DEFAULT,
       );
     }
 
-    if (t.schema.isString(type) && type.format === "uuid") {
-      return pgAttr(pgAttr(t.uuid(), PG_PRIMARY_KEY), PG_DEFAULT);
+    if (z.schema.isString(type) && z.schema.format(type) === "uuid") {
+      return pgAttr(pgAttr(z.uuid(), PG_PRIMARY_KEY), PG_DEFAULT);
     }
 
-    if (t.schema.isNumber(type) && type.format === "int64") {
+    if (z.schema.isNumber(type) && z.schema.format(type) === "int64") {
       return pgAttr(
-        pgAttr(
-          pgAttr(t.number(options), PG_PRIMARY_KEY),
-          PG_IDENTITY,
-          identity,
-        ),
+        pgAttr(pgAttr(z.number(), PG_PRIMARY_KEY), PG_IDENTITY, identity),
         PG_DEFAULT,
       );
     }
 
-    if (t.schema.isBigInt(type)) {
+    if (z.schema.isBigInt(type)) {
       return pgAttr(
-        pgAttr(
-          pgAttr(t.bigint(options), PG_PRIMARY_KEY),
-          PG_IDENTITY,
-          identity,
-        ),
+        pgAttr(pgAttr(z.bigint(), PG_PRIMARY_KEY), PG_IDENTITY, identity),
         PG_DEFAULT,
       );
     }
@@ -162,28 +143,28 @@ export class DatabaseTypeProvider {
    * @see {@link RepositoryPrimitive#save}
    * @see {@link PgVersionMismatchError}
    */
-  public readonly version = (options: TNumberOptions = {}) =>
-    this.default(pgAttr(t.integer(options), PG_VERSION), 0);
+  public readonly version = () =>
+    this.default(pgAttr(z.integer(), PG_VERSION), 0);
 
   /**
    * Creates a column Created At. So just a datetime column with a default value of the current timestamp.
    */
-  public readonly createdAt = (options?: TStringOptions) =>
-    pgAttr(pgAttr(t.datetime(options), PG_CREATED_AT), PG_DEFAULT);
+  public readonly createdAt = () =>
+    pgAttr(pgAttr(z.datetime(), PG_CREATED_AT), PG_DEFAULT);
 
   /**
    * Creates a column Updated At. Like createdAt, but it is updated on every update of the row.
    */
-  public readonly updatedAt = (options?: TStringOptions) =>
-    pgAttr(pgAttr(t.datetime(options), PG_UPDATED_AT), PG_DEFAULT);
+  public readonly updatedAt = () =>
+    pgAttr(pgAttr(z.datetime(), PG_UPDATED_AT), PG_DEFAULT);
 
   /**
    * Creates a column Deleted At for soft delete functionality.
    * This is used to mark rows as deleted without actually removing them from the database.
    * The column is nullable - NULL means not deleted, timestamp means deleted.
    */
-  public readonly deletedAt = (options?: TStringOptions) =>
-    pgAttr(t.optional(t.datetime(options)), PG_DELETED_AT);
+  public readonly deletedAt = () =>
+    pgAttr(z.datetime().optional(), PG_DELETED_AT);
 
   /**
    * Creates an organization column for multi-tenant row scoping.
@@ -193,12 +174,27 @@ export class DatabaseTypeProvider {
    *
    * @param options.nullable - When `false`, the column is NOT NULL in the database and
    *   the ORM rejects inserts that arrive without an organization context.
-   *   Defaults to `true` (nullable) for backward compatibility: NULL rows are visible
-   *   to every tenant, which is the historic "global row" semantics.
+   *   Defaults to `true` (nullable) — unless `strict` is set, which flips the
+   *   default to non-nullable. NULL rows are visible to every tenant (the
+   *   historic "global row" semantics) only when the column is nullable AND
+   *   not strict.
+   * @param options.strict - Fail-closed tenant scoping for security-sensitive
+   *   tables. Refuses reads/writes with no resolved tenant (instead of a
+   *   fail-open "see/write everything") and drops the `OR org IS NULL` escape
+   *   so a scoped tenant never sees global rows. Defaults to `false`.
    */
-  public readonly organization = (options?: { nullable?: boolean }) => {
-    const nullable = options?.nullable ?? true;
-    return pgAttr(nullable ? t.optional(t.uuid()) : t.uuid(), PG_ORGANIZATION);
+  public readonly organization = (options?: {
+    nullable?: boolean;
+    strict?: boolean;
+  }) => {
+    const strict = options?.strict ?? false;
+    // A strict (fail-closed) column has no "global row" concept, so it is
+    // non-nullable by default — but an explicit `nullable` still wins so
+    // legacy NULL rows can coexist while remaining invisible to tenants.
+    const nullable = options?.nullable ?? !strict;
+    return pgAttr(nullable ? z.uuid().optional() : z.uuid(), PG_ORGANIZATION, {
+      strict,
+    });
   };
 
   /**
@@ -214,7 +210,7 @@ export class DatabaseTypeProvider {
   ): PgAttr<T, PgRef> => {
     // If actions are not provided, set default onDelete based on type
     const finalActions = actions ?? {
-      onDelete: t.schema.isOptional(type) ? "set null" : "cascade",
+      onDelete: z.schema.isOptional(type) ? "set null" : "cascade",
     };
 
     return this.attr(type, PG_REF, {
@@ -229,11 +225,8 @@ export class DatabaseTypeProvider {
    * Creates a page schema for a given object schema.
    * It's used by {@link Repository#paginate} method.
    */
-  public readonly page = <T extends TObject>(
-    resource: T,
-    options?: TObjectOptions,
-  ): TPage<T> => {
-    return pageSchema(resource, options);
+  public readonly page = <T extends TObject>(resource: T): TPage<T> => {
+    return pageSchema(resource);
   };
 }
 

package/src/orm/core/providers/drivers/BunSqliteProvider.ts

@@ -9,7 +9,7 @@ import {
   $state,
   AlephaError,
   type Static,
-  t,
+  z,
 } from "alepha";
 import type { BunSQLiteDatabase } from "drizzle-orm/bun-sqlite";
 import type { PgDatabase } from "drizzle-orm/pg-core";
@@ -26,13 +26,13 @@ const envSchema = databaseEnvSchema;
  */
 export const bunSqliteOptions = $atom({
   name: "alepha.postgres.bun-sqlite.options",
-  schema: t.object({
-    path: t.optional(
-      t.string({
-        description:
-          "Filepath or :memory:. If empty, provider will use DATABASE_URL from env.",
-      }),
-    ),
+  schema: z.object({
+    path: z
+      .string()
+      .describe(
+        "Filepath or :memory:. If empty, provider will use DATABASE_URL from env.",
+      )
+      .optional(),
   }),
   default: {},
 });

package/src/orm/core/providers/drivers/CloudflareD1Provider.ts

@@ -1,4 +1,4 @@
-import { $env, $hook, $inject, AlephaError, t } from "alepha";
+import { $env, $hook, $inject, AlephaError, z } from "alepha";
 import type { DrizzleD1Database } from "drizzle-orm/d1";
 import type { PgDatabase } from "drizzle-orm/pg-core";
 import { SqliteModelBuilder } from "../../services/SqliteModelBuilder.ts";
@@ -49,10 +49,8 @@ export interface D1ExecResult {
 export class CloudflareD1Provider extends DatabaseProvider {
   protected readonly builder = $inject(SqliteModelBuilder);
   protected readonly env = $env(
-    t.object({
-      DATABASE_URL: t.string({
-        description: "Expect to be 'd1://binding'",
-      }),
+    z.object({
+      DATABASE_URL: z.string().describe("Expect to be 'd1://binding'"),
     }),
   );
 

package/src/orm/core/providers/drivers/NodeSqliteProvider.ts

@@ -9,7 +9,7 @@ import {
   $state,
   AlephaError,
   type Static,
-  t,
+  z,
 } from "alepha";
 import { migrate } from "drizzle-orm/better-sqlite3/migrator";
 import { BetterSQLiteSession } from "drizzle-orm/better-sqlite3/session";
@@ -50,13 +50,13 @@ const envSchema = databaseEnvSchema;
  */
 export const nodeSqliteOptions = $atom({
   name: "alepha.postgres.node-sqlite.options",
-  schema: t.object({
-    path: t.optional(
-      t.string({
-        description:
-          "Filepath or :memory:. If empty, provider will use DATABASE_URL from env.",
-      }),
-    ),
+  schema: z.object({
+    path: z
+      .string()
+      .describe(
+        "Filepath or :memory:. If empty, provider will use DATABASE_URL from env.",
+      )
+      .optional(),
   }),
   default: {},
 });

package/src/orm/core/schemas/databaseEnvSchema.ts

@@ -1,4 +1,4 @@
-import { type Static, t } from "alepha";
+import { type Static, z } from "alepha";
 
 /**
  * Base database environment schema.
@@ -13,8 +13,8 @@ import { type Static, t } from "alepha";
  * - `d1://BINDING_NAME` — Cloudflare D1
  * - `hyperdrive://BINDING_NAME` — Cloudflare Hyperdrive
  */
-export const databaseEnvSchema = t.object({
-  DATABASE_URL: t.optional(t.text()),
+export const databaseEnvSchema = z.object({
+  DATABASE_URL: z.text().optional(),
 
   /**
    * Enable or disable push-based schema synchronization (drizzle-kit push).
@@ -23,7 +23,7 @@ export const databaseEnvSchema = t.object({
    * Set to `false` in development to skip automatic schema sync
    * (e.g. when managing migrations manually).
    */
-  DATABASE_SYNC: t.optional(t.boolean()),
+  DATABASE_SYNC: z.boolean().optional(),
 });
 
 declare module "alepha" {

package/src/orm/core/schemas/insertSchema.ts

@@ -1,5 +1,5 @@
-import type { TObject, TOptional } from "alepha";
-import { t } from "alepha";
+import type { TObject, TOptional, TSchema } from "alepha";
+import { z } from "alepha";
 import {
   PG_DEFAULT,
   PG_GENERATED,
@@ -16,23 +16,20 @@ import {
  * After:  { name: string; age?: number; }
  */
 export type TObjectInsert<T extends TObject> = TObject<{
-  [K in keyof T["properties"] as T["properties"][K] extends {
-    [PG_GENERATED]: any;
-  }
+  [K in keyof T["shape"] as T["shape"][K] extends { [PG_GENERATED]: any }
     ? never
-    : K]: T["properties"][K] extends
+    : K]: T["shape"][K] extends
     | { [PG_DEFAULT]: any }
     | { [PG_ORGANIZATION]: any }
-    | { "~optional": true }
-    ? TOptional<T["properties"][K]>
-    : T["properties"][K];
+    ? TOptional<Extract<T["shape"][K], TSchema>>
+    : T["shape"][K];
 }>;
 
 export const insertSchema = <T extends TObject>(obj: T): TObjectInsert<T> => {
   const newProperties: Record<string, any> = {};
 
-  for (const key in obj.properties) {
-    const prop = obj.properties[key];
+  for (const key in obj.shape) {
+    const prop = obj.shape[key];
 
     // Skip generated columns — they are computed by the database
     if (PG_GENERATED in prop) {
@@ -43,16 +40,15 @@ export const insertSchema = <T extends TObject>(obj: T): TObjectInsert<T> => {
       // PG_DEFAULT fields have a server-side default; PG_ORGANIZATION fields are
       // auto-stamped by stampOrganization() inside create(). Both are optional
       // at the TypeScript call-site even when the DB column is NOT NULL.
-      newProperties[key] = t.optional(prop);
+      newProperties[key] = prop.optional();
+    } else if (z.schema.isOptional(prop)) {
+      // An optional field maps to a NULLABLE column, so an explicit `null` is a
+      // valid insert value (means "no value"), not just `undefined`.
+      newProperties[key] = z.schema.unwrap(prop).nullable().optional();
     } else {
       newProperties[key] = prop;
     }
   }
 
-  return t.object(
-    newProperties,
-    "options" in obj && typeof obj.options === "object"
-      ? { ...obj.options }
-      : {},
-  ) as TObjectInsert<T>;
+  return z.object(newProperties) as unknown as TObjectInsert<T>;
 };

package/src/orm/core/schemas/legacyIdSchema.ts

@@ -1,4 +1,4 @@
-import { t } from "alepha";
+import { z } from "alepha";
 import {
   PG_DEFAULT,
   PG_PRIMARY_KEY,
@@ -10,6 +10,6 @@ import { pgAttr } from "../helpers/pgAttr.ts";
  * @deprecated Use `pg.primaryKey()` instead.
  */
 export const legacyIdSchema = pgAttr(
-  pgAttr(pgAttr(t.integer(), PG_PRIMARY_KEY), PG_SERIAL),
+  pgAttr(pgAttr(z.integer(), PG_PRIMARY_KEY), PG_SERIAL),
   PG_DEFAULT,
 );

package/src/orm/core/schemas/updateSchema.ts

@@ -2,8 +2,9 @@ import {
   type TNull,
   type TObject,
   type TOptional,
+  type TSchema,
   type TUnion,
-  t,
+  z,
 } from "alepha";
 import { PG_GENERATED } from "../constants/PG_SYMBOLS.ts";
 
@@ -17,13 +18,11 @@ import { PG_GENERATED } from "../constants/PG_SYMBOLS.ts";
  * After:  { name?: string | null; age: number; }
  */
 export type TObjectUpdate<T extends TObject> = TObject<{
-  [K in keyof T["properties"] as T["properties"][K] extends {
-    [PG_GENERATED]: any;
-  }
+  [K in keyof T["shape"] as T["shape"][K] extends { [PG_GENERATED]: any }
     ? never
-    : K]: T["properties"][K] extends TOptional<infer U>
+    : K]: T["shape"][K] extends TOptional<infer U extends TSchema>
     ? TOptional<TUnion<[U, TNull]>>
-    : T["properties"][K];
+    : T["shape"][K];
 }>;
 
 export const updateSchema = <T extends TObject>(
@@ -31,25 +30,20 @@ export const updateSchema = <T extends TObject>(
 ): TObjectUpdate<T> => {
   const newProperties: Record<string, any> = {};
 
-  for (const key in schema.properties) {
-    const prop = schema.properties[key];
+  for (const key in schema.shape) {
+    const prop = schema.shape[key];
 
     // Skip generated columns — they are computed by the database
     if (PG_GENERATED in prop) {
       continue;
     }
 
-    if (t.schema.isOptional(prop)) {
-      newProperties[key] = t.optional(t.union([prop, t.null()]));
+    if (z.schema.isOptional(prop)) {
+      newProperties[key] = z.union([prop, z.null()]).optional();
     } else {
       newProperties[key] = prop;
     }
   }
 
-  return t.object(
-    newProperties,
-    "options" in schema && typeof schema.options === "object"
-      ? { ...schema.options }
-      : {},
-  ) as TObjectUpdate<T>;
+  return z.object(newProperties) as unknown as TObjectUpdate<T>;
 };

package/src/orm/core/services/PgRelationManager.ts

@@ -1,4 +1,4 @@
-import { $inject, SchemaValidator, type TObject, t } from "alepha";
+import { $inject, SchemaValidator, type TObject } from "alepha";
 import { getTableName, type SQL, sql } from "drizzle-orm";
 import type { PgSelectBase, PgTableWithColumns } from "drizzle-orm/pg-core";
 import { isSQLWrapper } from "drizzle-orm/sql/sql";
@@ -124,7 +124,7 @@ export class PgRelationManager {
       }
 
       // Make the join optional (left joins may return null)
-      schema.properties[join.key] = t.optional(joinSchema);
+      schema.properties[join.key] = joinSchema.optional();
     }
 
     return schema;

package/src/orm/core/services/QueryManager.ts

@@ -136,12 +136,23 @@ export class QueryManager {
             })
             .filter((it) => it != null);
 
+          // Combine with the sibling conditions instead of returning early —
+          // an early return here silently DROPPED every other key of the
+          // where (e.g. `{ userId: {...}, or: [...] }` matched ALL users).
           if (key === "and") {
-            return and(...operations);
+            const combined = and(...operations);
+            if (combined) {
+              conditions.push(combined);
+            }
+            continue;
           }
 
           if (key === "or") {
-            return or(...operations);
+            const combined = or(...operations);
+            if (combined) {
+              conditions.push(combined);
+            }
+            continue;
           }
         }