rado 1.2.1 → 1.3.0-preview.1

package/dist/postgres/columns.js

@@ -1,38 +1,233 @@
 // src/postgres/columns.ts
 import {
-  JsonColumn,
+  Column,
+  ColumnType,
   column,
   columnConfig
 } from "../core/Column.js";
-function bigint(name, options) {
-  return column({
+import { getData } from "../core/Internal.js";
+import { sql } from "../core/Sql.js";
+var GEOMETRY_TYPE = /^(geometry|point|line|linestring|polygon|multipoint|multilinestring|multipolygon|geometrycollection|circularstring|compoundcurve|curvepolygon|multicurve|multisurface|polyhedralsurface|triangle|tin)(z|m|zm)?$/;
+function parsePoint(value) {
+  const cleaned = value.trim().replace(/^\(/, "").replace(/\)$/, "");
+  const [x, y] = cleaned.split(",").map((v) => Number.parseFloat(v));
+  return [x, y];
+}
+function formatPoint(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) return `(${value[0]},${value[1]})`;
+  return `(${value.x},${value.y})`;
+}
+function parseLine(value) {
+  const cleaned = value.trim().replace(/^[({[]/, "").replace(/[)}\]]$/, "");
+  const [a, b, c] = cleaned.split(",").map((v) => Number.parseFloat(v));
+  return [a, b, c];
+}
+function formatLine(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) return `{${value[0]},${value[1]},${value[2]}}`;
+  return `{${value.a},${value.b},${value.c}}`;
+}
+function pad2(value) {
+  return String(value).padStart(2, "0");
+}
+function pad3(value) {
+  return String(value).padStart(3, "0");
+}
+function formatDateString(value) {
+  return `${value.getUTCFullYear()}-${pad2(value.getUTCMonth() + 1)}-${pad2(
+    value.getUTCDate()
+  )}`;
+}
+function formatTimestampString(value, withTimeZone) {
+  const date2 = formatDateString(value);
+  const time2 = `${pad2(value.getUTCHours())}:${pad2(
+    value.getUTCMinutes()
+  )}:${pad2(value.getUTCSeconds())}.${pad3(value.getUTCMilliseconds())}`;
+  return withTimeZone ? `${date2} ${time2}+00` : `${date2} ${time2}`;
+}
+function parsePgArrayValue(input) {
+  if (!input.startsWith("{") || !input.endsWith("}")) return [input];
+  const source = input.slice(1, -1);
+  const parts = [];
+  let token = "";
+  let depth = 0;
+  let inQuotes = false;
+  let wasQuoted = false;
+  const pushToken = () => {
+    if (!wasQuoted && token === "NULL") parts.push("\0NULL");
+    else parts.push(token);
+    token = "";
+    wasQuoted = false;
+  };
+  for (let i = 0; i < source.length; i++) {
+    const char2 = source[i];
+    if (inQuotes) {
+      if (char2 === "\\") {
+        const next = source[++i];
+        if (next !== void 0) token += next;
+        continue;
+      }
+      if (char2 === '"') {
+        inQuotes = false;
+        wasQuoted = true;
+        continue;
+      }
+      token += char2;
+      continue;
+    }
+    if (char2 === '"') {
+      inQuotes = true;
+      continue;
+    }
+    if (char2 === "{") {
+      depth++;
+      token += char2;
+      continue;
+    }
+    if (char2 === "}") {
+      depth--;
+      token += char2;
+      continue;
+    }
+    if (char2 === "," && depth === 0) {
+      pushToken();
+      continue;
+    }
+    token += char2;
+  }
+  pushToken();
+  return parts.map((part) => {
+    if (part === "\0NULL") return null;
+    if (part.startsWith("{") && part.endsWith("}"))
+      return parsePgArrayValue(part);
+    return part;
+  });
+}
+function serializePgArrayValue(value) {
+  return `{${value.map(serializePgArrayItem).join(",")}}`;
+}
+function serializePgArrayItem(value) {
+  if (Array.isArray(value)) return serializePgArrayValue(value);
+  if (value === null || value === void 0) return "NULL";
+  let normalized;
+  if (value instanceof Date) normalized = value.toISOString();
+  else if (typeof value === "string") normalized = value;
+  else if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint")
+    normalized = String(value);
+  else normalized = JSON.stringify(value);
+  const escaped = normalized.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return `"${escaped}"`;
+}
+function mapArrayItems(value, mapper) {
+  if (!Array.isArray(value)) return value;
+  return value.map((item) => mapper(item));
+}
+var PgColumn = class _PgColumn extends Column {
+  notNull() {
+    return new _PgColumn({
+      ...getData(this),
+      notNull: true
+    });
+  }
+  unique(name, config) {
+    return new _PgColumn({
+      ...getData(this),
+      isUnique: true,
+      nullsNotDistinct: config?.nulls === "not distinct",
+      name
+    });
+  }
+  array(size) {
+    const data = getData(this);
+    const mapTo = data.mapToDriverValue;
+    const mapFrom = data.mapFromDriverValue;
+    return new _PgColumn({
+      ...data,
+      type: new ColumnType("array", [data.type], sql`${data.type}[${size}]`),
+      mapToDriverValue(value) {
+        if (!Array.isArray(value)) return value;
+        const mapped = mapArrayItems(
+          value,
+          (item) => item !== null && item !== void 0 && mapTo ? mapTo(item) : item
+        );
+        return serializePgArrayValue(mapped);
+      },
+      mapFromDriverValue(value, specs) {
+        const parsed = typeof value === "string" ? parsePgArrayValue(value) : value;
+        if (!Array.isArray(parsed)) return parsed;
+        return mapArrayItems(
+          parsed,
+          (item) => item !== null && item !== void 0 && mapFrom ? mapFrom(item, specs) : item
+        );
+      }
+    });
+  }
+  generatedAlwaysAsIdentity() {
+    const data = getData(this);
+    return new _PgColumn({
+      ...data,
+      type: new ColumnType(
+        data.type.kind,
+        data.type.args,
+        sql`${data.type} generated always as identity`
+      )
+    });
+  }
+  generatedByDefaultAsIdentity() {
+    const data = getData(this);
+    return new _PgColumn({
+      ...data,
+      type: new ColumnType(
+        data.type.kind,
+        data.type.args,
+        sql`${data.type} generated by default as identity`
+      )
+    });
+  }
+};
+function bigint(...args) {
+  const { name, options } = columnConfig(args);
+  return new PgColumn({
     name,
     type: column.bigint(),
     mapFromDriverValue: options?.mode === "number" ? Number : BigInt
   });
 }
-function bigserial(name, options) {
-  return column({
+function bigserial(...args) {
+  const { name, options } = columnConfig(args);
+  return new PgColumn({
     name,
     type: column.bigserial(),
     mapFromDriverValue: options?.mode === "number" ? Number : BigInt
   });
 }
 function char(name, options) {
-  return column({
+  return new PgColumn({
     name,
     type: column.character(options?.length ?? 1)
   });
 }
+function bit(...args) {
+  const { name, options } = columnConfig(args);
+  return new PgColumn({ name, type: column.bit(options?.dimensions) });
+}
+function varbit(...args) {
+  const { name, options } = columnConfig(args);
+  return new PgColumn({ name, type: column.varbit(options?.dimensions) });
+}
 function cidr(name) {
-  return column({ name, type: column.cidr() });
+  return new PgColumn({ name, type: column.cidr() });
 }
 function date(name, options) {
-  return column({
+  const mode = options?.mode ?? "date";
+  return new PgColumn({
     name,
     type: column.date(),
     mapFromDriverValue(value) {
-      return options?.mode === "date" ? Date.parse(value) : value;
+      if (mode === "date")
+        return value instanceof Date ? value : new Date(value);
+      return value instanceof Date ? formatDateString(value) : value;
     },
     mapToDriverValue(value) {
       return value instanceof Date ? value.toISOString() : value;
@@ -40,7 +235,7 @@ function date(name, options) {
   });
 }
 function doublePrecision(name) {
-  return column({
+  return new PgColumn({
     name,
     type: column["double precision"](),
     mapFromDriverValue(value) {
@@ -49,18 +244,48 @@ function doublePrecision(name) {
   });
 }
 function inet(name) {
-  return column({ name, type: column.inet() });
+  return new PgColumn({ name, type: column.inet() });
 }
 function integer(name) {
-  return column({ name, type: column.integer() });
+  return new PgColumn({ name, type: column.integer() });
 }
 var int = integer;
 function oid(name) {
-  return column({ name, type: column.oid() });
+  return new PgColumn({ name, type: column.oid() });
+}
+function point(...args) {
+  const { name, options } = columnConfig(args);
+  const mode = options?.mode ?? "tuple";
+  return new PgColumn({
+    name,
+    type: column.point(),
+    mapFromDriverValue(value) {
+      const [x, y] = parsePoint(value);
+      return mode === "xy" ? { x, y } : [x, y];
+    },
+    mapToDriverValue(value) {
+      return formatPoint(value);
+    }
+  });
+}
+function line(...args) {
+  const { name, options } = columnConfig(args);
+  const mode = options?.mode ?? "tuple";
+  return new PgColumn({
+    name,
+    type: column.line(),
+    mapFromDriverValue(value) {
+      const [a, b, c] = parseLine(value);
+      return mode === "abc" ? { a, b, c } : [a, b, c];
+    },
+    mapToDriverValue(value) {
+      return formatLine(value);
+    }
+  });
 }
 function interval(...args) {
   const { name, options } = columnConfig(args);
-  return column({
+  return new PgColumn({
     name,
     type: column[options?.fields ? `interval ${options.fields}` : "interval"](
       options?.precision
@@ -68,19 +293,19 @@ function interval(...args) {
   });
 }
 function serial(name) {
-  return column({ name, type: column.serial() });
+  return new PgColumn({ name, type: column.serial() });
 }
 function boolean(name) {
-  return column({ name, type: column.boolean() });
+  return new PgColumn({ name, type: column.boolean() });
 }
 function bytea(name) {
-  return column({ name, type: column.bytea() });
+  return new PgColumn({ name, type: column.bytea() });
 }
 function text(name) {
-  return column({ name, type: column.text() });
+  return new PgColumn({ name, type: column.text() });
 }
 function json(name) {
-  return new JsonColumn({
+  return new PgColumn({
     name,
     type: column.json(),
     mapToDriverValue(value) {
@@ -88,11 +313,12 @@ function json(name) {
     },
     mapFromDriverValue(value, { parsesJson }) {
       return parsesJson ? value : JSON.parse(value);
-    }
+    },
+    json: true
   });
 }
 function jsonb(name) {
-  return new JsonColumn({
+  return new PgColumn({
     name,
     type: column.jsonb(),
     mapToDriverValue(value) {
@@ -100,24 +326,64 @@ function jsonb(name) {
     },
     mapFromDriverValue(value, { parsesJson }) {
       return parsesJson ? value : JSON.parse(value);
+    },
+    json: true
+  });
+}
+function geometry(...args) {
+  const { name, options } = columnConfig(args);
+  const geometryTypeName = options?.type?.toLowerCase();
+  if (geometryTypeName && !GEOMETRY_TYPE.test(geometryTypeName)) {
+    throw new Error(`Invalid geometry type: ${options?.type}`);
+  }
+  const typeArg = geometryTypeName ? sql.unsafe(geometryTypeName) : void 0;
+  const geometryType = options?.type ? new ColumnType("geometry", [], sql`geometry(${typeArg})`) : column.geometry();
+  const mode = options?.mode ?? "tuple";
+  const mapsPoint = geometryTypeName === "point";
+  return new PgColumn({
+    name,
+    type: geometryType,
+    mapFromDriverValue(value) {
+      if (!mapsPoint) return value;
+      const [x, y] = parsePoint(value);
+      return mode === "xy" ? { x, y } : [x, y];
+    },
+    mapToDriverValue(value) {
+      if (!mapsPoint) return value;
+      return formatPoint(value);
     }
   });
 }
+function vector(...args) {
+  const { name, options } = columnConfig(args);
+  return new PgColumn({ name, type: column.vector(options?.dimensions) });
+}
+function halfvec(...args) {
+  const { name, options } = columnConfig(args);
+  return new PgColumn({ name, type: column.halfvec(options?.dimensions) });
+}
+function sparsevec(...args) {
+  const { name, options } = columnConfig(args);
+  return new PgColumn({ name, type: column.sparsevec(options?.dimensions) });
+}
 function macaddr(name) {
-  return column({ name, type: column.macaddr() });
+  return new PgColumn({ name, type: column.macaddr() });
 }
 function macaddr8(name) {
-  return column({ name, type: column.macaddr8() });
+  return new PgColumn({ name, type: column.macaddr8() });
 }
 function numeric(...args) {
   const { name, options } = columnConfig(args);
-  return column({
+  const mode = options?.mode;
+  const mapFromDriverValue = mode && (mode === "bigint" ? BigInt : Number);
+  return new PgColumn({
     name,
-    type: column.numeric(options?.precision, options?.scale)
+    type: column.numeric(options?.precision, options?.scale),
+    mapFromDriverValue
   });
 }
 function real(name) {
-  return column({
+  return new PgColumn({
     name,
     type: column.real(),
     mapFromDriverValue(value) {
@@ -126,14 +392,14 @@ function real(name) {
   });
 }
 function smallint(name) {
-  return column({ name, type: column.smallint() });
+  return new PgColumn({ name, type: column.smallint() });
 }
 function smallserial(name) {
-  return column({ name, type: column.smallserial() });
+  return new PgColumn({ name, type: column.smallserial() });
 }
 function time(...args) {
   const { name, options } = columnConfig(args);
-  return column({
+  return new PgColumn({
     name,
     type: column[options?.withTimeZone ? "time with time zone" : "time"](
       options?.precision
@@ -142,11 +408,18 @@ function time(...args) {
 }
 function timestamp(...args) {
   const { name, options } = columnConfig(args);
-  return column({
+  const withTimeZone = options?.withTimeZone ?? options?.withTimezone;
+  const mode = options?.mode ?? "date";
+  return new PgColumn({
     name,
-    type: column[options?.withTimeZone ? "timestamp with time zone" : "timestamp"](options?.precision),
+    type: column[withTimeZone ? "timestamp with time zone" : "timestamp"](
+      options?.precision
+    ),
     mapFromDriverValue(value) {
-      return options?.mode === "string" ? value : Date.parse(value);
+      if (mode === "string") {
+        return value instanceof Date ? formatTimestampString(value, !!withTimeZone) : value;
+      }
+      return value instanceof Date ? value : new Date(value);
     },
     mapToDriverValue(value) {
       return value instanceof Date ? value.toISOString() : value;
@@ -154,41 +427,50 @@ function timestamp(...args) {
   });
 }
 function uuid(name) {
-  return column({ name, type: column.uuid() });
+  return new PgColumn({ name, type: column.uuid() });
 }
 function varchar(...args) {
   const { name, options } = columnConfig(args);
-  return column({
+  return new PgColumn({
     name,
     type: column.varchar(options?.length)
   });
 }
 export {
+  PgColumn,
   bigint,
   bigserial,
+  bit,
   boolean,
   bytea,
   char,
   cidr,
   date,
   doublePrecision,
+  geometry,
+  halfvec,
   inet,
   int,
   integer,
   interval,
   json,
   jsonb,
+  line,
   macaddr,
   macaddr8,
   numeric,
   oid,
+  point,
   real,
   serial,
   smallint,
   smallserial,
+  sparsevec,
   text,
   time,
   timestamp,
   uuid,
-  varchar
+  varbit,
+  varchar,
+  vector
 };

package/dist/postgres/diff.js

@@ -1,8 +1,5 @@
 // src/postgres/diff.ts
 import { formatColumn } from "../core/Column.js";
-import { getData, getTable } from "../core/Internal.js";
-import { sql } from "../core/Sql.js";
-import { table } from "../core/Table.js";
 import {
   and,
   asc,
@@ -15,6 +12,9 @@ import {
   or,
   when
 } from "../core/expr/Conditions.js";
+import { getData, getTable } from "../core/Internal.js";
+import { sql } from "../core/Sql.js";
+import { table } from "../core/Table.js";
 import { concat, txGenerator } from "../universal.js";
 import * as column from "./columns.js";
 import { postgresDialect } from "./dialect.js";

package/dist/postgres/enum.d.ts

@@ -0,0 +1,17 @@
+import { type HasCreate, type HasDrop } from '../core/Internal.js';
+import type { Sql } from '../core/Sql.js';
+import type { TableApi } from '../core/Table.js';
+import { PgColumn } from './columns.js';
+export interface PgEnum<Values extends EnumInput> extends HasCreate, HasDrop {
+    (name?: string): PgColumn<Values[keyof Values] | null>;
+}
+export interface PgEnumInfo {
+    name: string;
+    schema?: string;
+    values: readonly string[];
+}
+type EnumInput = readonly [string, ...string[]] | Record<string, string>;
+export declare function pgEnum<const Name extends string, const Values extends EnumInput>(name: Name, values: Values, schemaName?: string): PgEnum<Values>;
+export declare function enumQuery(enumInfo: PgEnumInfo): Sql;
+export declare function collectEnumQuery(table: TableApi): Array<Sql>;
+export {};

package/dist/postgres/enum.js

@@ -0,0 +1,64 @@
+// src/postgres/enum.ts
+import { ColumnType } from "../core/Column.js";
+import {
+  getData,
+  getEnum,
+  hasEnum,
+  internalCreate,
+  internalDrop,
+  internalEnum
+} from "../core/Internal.js";
+import { sql } from "../core/Sql.js";
+import { PgColumn } from "./columns.js";
+function pgEnum(name, values, schemaName) {
+  const enumIdentifier = schemaName ? sql.join([sql.identifier(schemaName), sql.identifier(name)], sql`.`) : sql.identifier(name);
+  const enumType = new ColumnType(name, [], enumIdentifier);
+  const v = Array.isArray(values) ? values : Object.values(values);
+  const info = { name, schema: schemaName, values: v };
+  return Object.assign(
+    (columnName) => {
+      return new PgColumn({
+        name: columnName,
+        type: enumType,
+        [internalEnum]: info
+      });
+    },
+    {
+      get [internalCreate]() {
+        return [enumQuery(info)];
+      },
+      get [internalDrop]() {
+        return [sql`drop type if exists ${enumIdentifier}`];
+      }
+    }
+  );
+}
+function enumQuery(enumInfo) {
+  const enumIdentifier = enumInfo.schema ? sql.join(
+    [sql.identifier(enumInfo.schema), sql.identifier(enumInfo.name)],
+    sql`.`
+  ) : sql.identifier(enumInfo.name);
+  return sql`do $$ begin create type ${enumIdentifier} as enum (${sql.join(
+    enumInfo.values.map(sql.inline),
+    sql`, `
+  )}); exception when duplicate_object then null; end $$`;
+}
+function collectEnumQuery(table) {
+  const enums = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const column of Object.values(table.columns)) {
+    const data = getData(column);
+    if (!hasEnum(data)) continue;
+    const info = getEnum(data);
+    const enumKey = info.schema ? `${info.schema}.${info.name}` : info.name;
+    if (seen.has(enumKey)) continue;
+    seen.add(enumKey);
+    enums.push(enumQuery(info));
+  }
+  return enums;
+}
+export {
+  collectEnumQuery,
+  enumQuery,
+  pgEnum
+};

package/dist/postgres/schema.d.ts

@@ -0,0 +1,19 @@
+import { type HasCreate, type HasDrop, internalCreate, internalDrop, internalTarget } from '../core/Internal.js';
+import { type Sql } from '../core/Sql.js';
+import type { Table, TableConfig, TableDefinition } from '../core/Table.js';
+import { type DefinedView, type QueryView } from '../core/View.js';
+import { type PgEnum } from './enum.js';
+export declare class PgSchema<SchemaName extends string> implements HasCreate, HasDrop {
+    #private;
+    constructor(schemaName: SchemaName);
+    get [internalTarget](): Sql;
+    get [internalCreate](): Array<Sql>;
+    get [internalDrop](): Array<Sql>;
+    table<Definition extends TableDefinition, TableName extends string>(tableName: TableName, columns: Definition, config?: (self: Table<Definition>) => TableConfig<TableName>): Table<Definition, TableName>;
+    enum<const Name extends string, const Values extends readonly [string, ...string[]]>(name: Name, values: Values): PgEnum<Values>;
+    view(name: string): QueryView;
+    view<Definition extends TableDefinition>(name: string, fields: Definition): DefinedView<Definition>;
+    materializedView(name: string): QueryView;
+    materializedView<Definition extends TableDefinition>(name: string, fields: Definition): DefinedView<Definition>;
+}
+export declare function pgSchema<SchemaName extends string>(schemaName: SchemaName): PgSchema<SchemaName>;

package/dist/postgres/schema.js

@@ -0,0 +1,47 @@
+// src/postgres/schema.ts
+import {
+  internalCreate,
+  internalDrop,
+  internalTarget
+} from "../core/Internal.js";
+import { sql } from "../core/Sql.js";
+import { table } from "../core/Table.js";
+import {
+  materializedView,
+  view
+} from "../core/View.js";
+import { pgEnum } from "./enum.js";
+var PgSchema = class {
+  #schemaName;
+  constructor(schemaName) {
+    this.#schemaName = schemaName;
+  }
+  get [internalTarget]() {
+    return sql.identifier(this.#schemaName);
+  }
+  get [internalCreate]() {
+    return [sql`create schema if not exists ${this}`];
+  }
+  get [internalDrop]() {
+    return [sql`drop schema if exists ${this} cascade`];
+  }
+  table(tableName, columns, config) {
+    return table(tableName, columns, config, this.#schemaName);
+  }
+  enum(name, values) {
+    return pgEnum(name, values, this.#schemaName);
+  }
+  view(name, fields) {
+    return view(name, fields, this.#schemaName);
+  }
+  materializedView(name, fields) {
+    return materializedView(name, fields, this.#schemaName);
+  }
+};
+function pgSchema(schemaName) {
+  return new PgSchema(schemaName);
+}
+export {
+  PgSchema,
+  pgSchema
+};

package/dist/postgres.d.ts

@@ -1,8 +1,10 @@
 export { foreignKey, primaryKey, unique } from './core/Constraint.js';
 export { index, uniqueIndex } from './core/Index.js';
 export { except, exceptAll, intersect, intersectAll, union, unionAll } from './core/query/Select.js';
-export { schema as pgSchema } from './core/Schema.js';
 export { alias, table as pgTable, tableCreator as pgTableCreator } from './core/Table.js';
+export { materializedView as pgMaterializedView, view as pgView } from './core/View.js';
 export * from './postgres/builder.js';
 export * from './postgres/columns.js';
 export * from './postgres/dialect.js';
+export * from './postgres/enum.js';
+export { pgSchema } from './postgres/schema.js';