@pramen/server 0.0.4 → 0.0.6

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { Entity, defineSchema, renamedFrom, notNull, unique, indexed, defaultTo, primaryKey, generated } from "./sdk/schema";
+export { Entity, defineSchema, renamedFrom, notNull, unique, indexed, defaultTo, primaryKey, generated, expr, ExprDefault } from "./sdk/schema";
 export { isValidUuid } from "./sdk/uuid";
 export type { DefaultValue, FieldType, FieldDef, EntityFields, EntityDef, SchemaDef, RelationDef, RelationDefs, BelongsToDef, HasManyDef, } from "./sdk/schema";
 export { createApp } from "./sdk/app";

package/dist/index.js

@@ -7,7 +7,7 @@
 // which only exists in the Workers runtime; keeping it separate lets the CLI, tests,
 // and codegen load an app.ts for its schema without dragging in the DO runtime.
 // --- schema authoring ---
-export { Entity, defineSchema, renamedFrom, notNull, unique, indexed, defaultTo, primaryKey, generated } from "./sdk/schema";
+export { Entity, defineSchema, renamedFrom, notNull, unique, indexed, defaultTo, primaryKey, generated, expr, ExprDefault } from "./sdk/schema";
 export { isValidUuid } from "./sdk/uuid";
 // --- app + handlers ---
 export { createApp } from "./sdk/app";

package/dist/runtime/ddl.js

@@ -19,10 +19,16 @@ function defaultLiteral(v) {
         return String(v);
     return `'${v.replace(/'/g, "''")}'`;
 }
-/** The ` DEFAULT x` fragment for a column, or "" when it has no default. UNIQUE/
- * index are NOT inline — they're emitted as separate index statements so the same
- * code path serves both CREATE TABLE and ALTER TABLE ADD COLUMN. */
+/** The ` DEFAULT x` fragment for a column, or "" when it has no default. A raw-SQL
+ * `defaultExpr` (e.g. `datetime('now')`) is emitted UNQUOTED; a literal `default` is
+ * quote-escaped. UNIQUE/index are NOT inline — they're emitted as separate index
+ * statements so the same code path serves both CREATE TABLE and ALTER TABLE ADD COLUMN. */
 function defaultSql(f) {
+    // A raw-SQL default is parenthesized: SQLite's column-DEFAULT grammar only takes a
+    // bare literal/keyword, so a function call (e.g. datetime('now')) must be wrapped —
+    // `DEFAULT (datetime('now'))`. Parens are harmless around a keyword too.
+    if (f.defaultExpr !== undefined)
+        return ` DEFAULT (${f.defaultExpr})`;
     return f.default !== undefined ? ` DEFAULT ${defaultLiteral(f.default)}` : "";
 }
 function columnSql(name, f) {

package/dist/runtime/migrate.js

@@ -114,9 +114,18 @@ export async function migrate(driver, schema, opts = {}) {
             continue;
         }
         // Pass 1 — additive: add any column the schema declares but the table lacks.
+        // SQLite forbids ALTER ADD COLUMN with a non-constant DEFAULT (e.g. expr.now()),
+        // so such a column is added via a table rebuild instead — which is still additive
+        // (no data loss): the rebuild's INSERT omits the new column, so SQLite applies its
+        // CREATE TABLE default, backfilling existing rows. Flagged here, done in Pass 2.
+        let needsAdditiveRebuild = false;
         for (const [name, field] of Object.entries(def.fields)) {
             if (existing.has(name))
                 continue;
+            if (field.defaultExpr !== undefined) {
+                needsAdditiveRebuild = true;
+                continue;
+            }
             await driver.exec(`ALTER TABLE ${ident(table)} ADD COLUMN ${addColumnSql(name, field)}`, []);
             added.push(`${table}.${name}`);
         }
@@ -132,14 +141,17 @@ export async function migrate(driver, schema, opts = {}) {
         }
         const needsDrop = [...live.keys()].some((c) => !desired.has(c) && !renamedSources.has(c));
         const needsTypeChange = Object.entries(def.fields).some(([n, f]) => live.has(n) && live.get(n) !== sqlType(f));
-        if (needsDrop || needsTypeChange || renamedSources.size > 0) {
-            if (allowDestructive) {
-                await rebuildTable(driver, table, def, live);
-                rebuilt.push(table);
-            }
-            else {
-                skipped.push(`rebuild ${table} (drop/type-change/rename)`);
-            }
+        const destructive = needsDrop || needsTypeChange || renamedSources.size > 0;
+        if (destructive && !allowDestructive) {
+            // The destructive part is gated off — skip the whole rebuild (any pending
+            // expr-default column waits until destructive migrations are allowed).
+            skipped.push(`rebuild ${table} (drop/type-change/rename)`);
+        }
+        else if (destructive || needsAdditiveRebuild) {
+            // An additive-only rebuild (just an expr-default column) needs no permission —
+            // it loses no data.
+            await rebuildTable(driver, table, def, live);
+            rebuilt.push(table);
         }
     }
     // Ensure unique/index declarations (idempotent, via IF NOT EXISTS). Indexes can be

package/dist/sdk/infer.d.ts

@@ -65,6 +65,8 @@ type RequiredInsertKeys<F extends EntityFields> = {
         generated: true;
     } ? never : F[K] extends {
         default: DefaultValue;
+    } ? never : F[K] extends {
+        defaultExpr: string;
     } ? never : K : never;
 }[keyof F];
 type OptionalInsertKeys<F extends EntityFields> = Exclude<keyof F, RequiredInsertKeys<F>>;

package/dist/sdk/schema.d.ts

@@ -16,6 +16,10 @@ export interface FieldDef {
     readonly generated?: boolean;
     /** A column DEFAULT (a literal). Makes the column optional on insert. */
     readonly default?: DefaultValue;
+    /** A column DEFAULT that is raw SQL, emitted UNQUOTED (e.g. `datetime('now')`) —
+     * set by `defaultTo(field, expr.now())`/`expr.raw(...)`. Distinct from `default`
+     * (a quoted literal). Makes the column optional on insert. */
+    readonly defaultExpr?: string;
     /** Migration hint: this column was previously named X. On boot the migrator
      * rebuilds the table, copying data from the old column. A diff cannot tell a
      * rename from a drop+add, so the rename must be declared explicitly. */
@@ -120,7 +124,26 @@ export declare function unique<F extends FieldDef>(field: F): F & {
 export declare function indexed<F extends FieldDef>(field: F): F & {
     readonly index: true;
 };
-/** Give the column a DEFAULT (a literal) — also makes it optional on insert. */
+/** A raw-SQL column DEFAULT (emitted unquoted in the DDL), produced by the `expr`
+ * helpers below. Distinct from a literal default so `defaultTo` can render
+ * `DEFAULT datetime('now')` rather than the quoted string `DEFAULT 'datetime(...)'`. */
+export declare class ExprDefault {
+    readonly sql: string;
+    constructor(sql: string);
+}
+/** SQL-expression defaults for `defaultTo(field, expr.now())`. `now()` is the current
+ * UTC timestamp as TEXT (`'YYYY-MM-DD HH:MM:SS'`, like `CURRENT_TIMESTAMP`) — pair it
+ * with `t.text()`. `raw(sql)` is an escape hatch for any other SQLite default expression. */
+export declare const expr: {
+    now: () => ExprDefault;
+    raw: (sql: string) => ExprDefault;
+};
+/** Give the column a DEFAULT — also makes it optional on insert. Pass a literal
+ * (rendered as a quoted SQL literal) or an `expr.*()` value (raw SQL, unquoted),
+ * e.g. `defaultTo(t.text(), "pending")` or `defaultTo(t.text(), expr.now())`. */
+export declare function defaultTo<F extends FieldDef>(field: F, value: ExprDefault): F & {
+    readonly defaultExpr: string;
+};
 export declare function defaultTo<F extends FieldDef, D extends DefaultValue>(field: F, value: D): F & {
     readonly default: D;
 };

package/dist/sdk/schema.js

@@ -57,9 +57,24 @@ export function unique(field) {
 export function indexed(field) {
     return { ...field, index: true };
 }
-/** Give the column a DEFAULT (a literal) — also makes it optional on insert. */
+/** A raw-SQL column DEFAULT (emitted unquoted in the DDL), produced by the `expr`
+ * helpers below. Distinct from a literal default so `defaultTo` can render
+ * `DEFAULT datetime('now')` rather than the quoted string `DEFAULT 'datetime(...)'`. */
+export class ExprDefault {
+    sql;
+    constructor(sql) {
+        this.sql = sql;
+    }
+}
+/** SQL-expression defaults for `defaultTo(field, expr.now())`. `now()` is the current
+ * UTC timestamp as TEXT (`'YYYY-MM-DD HH:MM:SS'`, like `CURRENT_TIMESTAMP`) — pair it
+ * with `t.text()`. `raw(sql)` is an escape hatch for any other SQLite default expression. */
+export const expr = {
+    now: () => new ExprDefault("datetime('now')"),
+    raw: (sql) => new ExprDefault(sql),
+};
 export function defaultTo(field, value) {
-    return { ...field, default: value };
+    return value instanceof ExprDefault ? { ...field, defaultExpr: value.sql } : { ...field, default: value };
 }
 /** Mark a column as the PRIMARY KEY (implies NOT NULL). Composes with any builder,
  * e.g. `id: primaryKey(generated(t.uuid()))` or `code: primaryKey(t.text())`. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pramen/server",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "pramen server runtime — schema, ACL, ORM, live queries, files, and the createPramen(app) factory for Cloudflare Workers + Durable Objects.",
   "license": "MIT",
   "repository": {

package/src/index.ts

@@ -8,7 +8,7 @@
 // and codegen load an app.ts for its schema without dragging in the DO runtime.
 
 // --- schema authoring ---
-export { Entity, defineSchema, renamedFrom, notNull, unique, indexed, defaultTo, primaryKey, generated } from "./sdk/schema";
+export { Entity, defineSchema, renamedFrom, notNull, unique, indexed, defaultTo, primaryKey, generated, expr, ExprDefault } from "./sdk/schema";
 export { isValidUuid } from "./sdk/uuid";
 export type {
   DefaultValue,

package/src/runtime/ddl.ts

@@ -22,10 +22,15 @@ function defaultLiteral(v: DefaultValue): string {
   return `'${v.replace(/'/g, "''")}'`;
 }
 
-/** The ` DEFAULT x` fragment for a column, or "" when it has no default. UNIQUE/
- * index are NOT inline — they're emitted as separate index statements so the same
- * code path serves both CREATE TABLE and ALTER TABLE ADD COLUMN. */
+/** The ` DEFAULT x` fragment for a column, or "" when it has no default. A raw-SQL
+ * `defaultExpr` (e.g. `datetime('now')`) is emitted UNQUOTED; a literal `default` is
+ * quote-escaped. UNIQUE/index are NOT inline — they're emitted as separate index
+ * statements so the same code path serves both CREATE TABLE and ALTER TABLE ADD COLUMN. */
 function defaultSql(f: FieldDef): string {
+  // A raw-SQL default is parenthesized: SQLite's column-DEFAULT grammar only takes a
+  // bare literal/keyword, so a function call (e.g. datetime('now')) must be wrapped —
+  // `DEFAULT (datetime('now'))`. Parens are harmless around a keyword too.
+  if (f.defaultExpr !== undefined) return ` DEFAULT (${f.defaultExpr})`;
   return f.default !== undefined ? ` DEFAULT ${defaultLiteral(f.default)}` : "";
 }
 

package/src/runtime/migrate.ts

@@ -157,8 +157,17 @@ export async function migrate(driver: Driver, schema: SchemaDef, opts: MigrateOp
       continue;
     }
     // Pass 1 — additive: add any column the schema declares but the table lacks.
+    // SQLite forbids ALTER ADD COLUMN with a non-constant DEFAULT (e.g. expr.now()),
+    // so such a column is added via a table rebuild instead — which is still additive
+    // (no data loss): the rebuild's INSERT omits the new column, so SQLite applies its
+    // CREATE TABLE default, backfilling existing rows. Flagged here, done in Pass 2.
+    let needsAdditiveRebuild = false;
     for (const [name, field] of Object.entries(def.fields)) {
       if (existing.has(name)) continue;
+      if ((field as FieldDef).defaultExpr !== undefined) {
+        needsAdditiveRebuild = true;
+        continue;
+      }
       await driver.exec(`ALTER TABLE ${ident(table)} ADD COLUMN ${addColumnSql(name, field as FieldDef)}`, []);
       added.push(`${table}.${name}`);
     }
@@ -176,13 +185,16 @@ export async function migrate(driver: Driver, schema: SchemaDef, opts: MigrateOp
     const needsTypeChange = Object.entries(def.fields).some(
       ([n, f]) => live.has(n) && live.get(n) !== sqlType(f as FieldDef),
     );
-    if (needsDrop || needsTypeChange || renamedSources.size > 0) {
-      if (allowDestructive) {
-        await rebuildTable(driver, table, def, live);
-        rebuilt.push(table);
-      } else {
-        skipped.push(`rebuild ${table} (drop/type-change/rename)`);
-      }
+    const destructive = needsDrop || needsTypeChange || renamedSources.size > 0;
+    if (destructive && !allowDestructive) {
+      // The destructive part is gated off — skip the whole rebuild (any pending
+      // expr-default column waits until destructive migrations are allowed).
+      skipped.push(`rebuild ${table} (drop/type-change/rename)`);
+    } else if (destructive || needsAdditiveRebuild) {
+      // An additive-only rebuild (just an expr-default column) needs no permission —
+      // it loses no data.
+      await rebuildTable(driver, table, def, live);
+      rebuilt.push(table);
     }
   }
 

package/src/sdk/infer.ts

@@ -113,7 +113,8 @@ export type WhereClause<S extends SchemaDef, T extends keyof S, D extends number
 export type InferUpdate<F extends EntityFields> = Partial<{ [K in keyof F]: FieldTsType<F[K]> | null }>;
 
 // Insert: a NOT NULL column is required unless it's auto-generated (autoIncrement,
-// or a `generated()` uuid the runtime mints) or has a DEFAULT (the DB fills it);
+// or a `generated()` uuid the runtime mints) or has a DEFAULT — a literal (`default`)
+// or a SQL expression (`defaultExpr`, e.g. expr.now()), both filled by the DB;
 // everything else is optional.
 type RequiredInsertKeys<F extends EntityFields> = {
   [K in keyof F]: IsNotNull<F[K]> extends true
@@ -123,7 +124,9 @@ type RequiredInsertKeys<F extends EntityFields> = {
         ? never
         : F[K] extends { default: DefaultValue }
           ? never
-          : K
+          : F[K] extends { defaultExpr: string }
+            ? never
+            : K
     : never;
 }[keyof F];
 type OptionalInsertKeys<F extends EntityFields> = Exclude<keyof F, RequiredInsertKeys<F>>;

package/src/sdk/schema.ts

@@ -31,6 +31,10 @@ export interface FieldDef {
   readonly generated?: boolean;
   /** A column DEFAULT (a literal). Makes the column optional on insert. */
   readonly default?: DefaultValue;
+  /** A column DEFAULT that is raw SQL, emitted UNQUOTED (e.g. `datetime('now')`) —
+   * set by `defaultTo(field, expr.now())`/`expr.raw(...)`. Distinct from `default`
+   * (a quoted literal). Makes the column optional on insert. */
+  readonly defaultExpr?: string;
   /** Migration hint: this column was previously named X. On boot the migrator
    * rebuilds the table, copying data from the old column. A diff cannot tell a
    * rename from a drop+add, so the rename must be declared explicitly. */
@@ -130,9 +134,28 @@ export function indexed<F extends FieldDef>(field: F): F & { readonly index: tru
   return { ...field, index: true };
 }
 
-/** Give the column a DEFAULT (a literal) — also makes it optional on insert. */
-export function defaultTo<F extends FieldDef, D extends DefaultValue>(field: F, value: D): F & { readonly default: D } {
-  return { ...field, default: value };
+/** A raw-SQL column DEFAULT (emitted unquoted in the DDL), produced by the `expr`
+ * helpers below. Distinct from a literal default so `defaultTo` can render
+ * `DEFAULT datetime('now')` rather than the quoted string `DEFAULT 'datetime(...)'`. */
+export class ExprDefault {
+  constructor(readonly sql: string) {}
+}
+
+/** SQL-expression defaults for `defaultTo(field, expr.now())`. `now()` is the current
+ * UTC timestamp as TEXT (`'YYYY-MM-DD HH:MM:SS'`, like `CURRENT_TIMESTAMP`) — pair it
+ * with `t.text()`. `raw(sql)` is an escape hatch for any other SQLite default expression. */
+export const expr = {
+  now: (): ExprDefault => new ExprDefault("datetime('now')"),
+  raw: (sql: string): ExprDefault => new ExprDefault(sql),
+};
+
+/** Give the column a DEFAULT — also makes it optional on insert. Pass a literal
+ * (rendered as a quoted SQL literal) or an `expr.*()` value (raw SQL, unquoted),
+ * e.g. `defaultTo(t.text(), "pending")` or `defaultTo(t.text(), expr.now())`. */
+export function defaultTo<F extends FieldDef>(field: F, value: ExprDefault): F & { readonly defaultExpr: string };
+export function defaultTo<F extends FieldDef, D extends DefaultValue>(field: F, value: D): F & { readonly default: D };
+export function defaultTo<F extends FieldDef>(field: F, value: DefaultValue | ExprDefault): FieldDef {
+  return value instanceof ExprDefault ? { ...field, defaultExpr: value.sql } : { ...field, default: value };
 }
 
 /** Mark a column as the PRIMARY KEY (implies NOT NULL). Composes with any builder,