effect-qb 0.19.0 → 4.0.0-beta.92

package/src/standard/column.ts

@@ -20,7 +20,7 @@ import {
 import { standardDatatypes } from "./datatypes/index.js"
 
 const primitive = <Type, Db extends Expression.DbType.Any>(
-  schema: Schema.Schema<Type, any, any>,
+  schema: Schema.Schema<Type>,
   dbType: Db
 ): ColumnDefinition<Type, Type, Type, Db, false, false, false, false, false, undefined> =>
   makeColumnDefinition(schema as Schema.Schema<NonNullable<Type>>, {
@@ -48,15 +48,15 @@ const renderNumericDdlType = (
 const boundedString = (length?: number): Schema.Schema<string> =>
   length === undefined
     ? Schema.String
-    : Schema.String.pipe(Schema.maxLength(length))
+    : Schema.String.check(Schema.isMaxLength(length))
 
-const finiteNumber = Schema.Number.pipe(Schema.finite())
+const finiteNumber = Schema.Number.check(Schema.isFinite())
 
-export const custom = <SchemaType extends Schema.Schema.Any, Db extends Expression.DbType.Any>(
+export const custom = <SchemaType extends Schema.Top, Db extends Expression.DbType.Any>(
   schema: SchemaType,
   dbType: Db
 ) =>
-  makeColumnDefinition(schema as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>>, {
     dbType: enrichDbType(standardDatatypes, dbType),
     nullable: false,
     hasDefault: false,
@@ -68,7 +68,7 @@ export const custom = <SchemaType extends Schema.Schema.Any, Db extends Expressi
     identity: undefined
   })
 
-export const uuid = () => primitive(Schema.UUID, standardDatatypes.uuid())
+export const uuid = () => primitive(Schema.String.check(Schema.isUUID()), standardDatatypes.uuid())
 export const text = () => primitive(Schema.String, standardDatatypes.text())
 export const varchar = (length?: number) =>
   makeColumnDefinition(boundedString(length), {
@@ -79,7 +79,7 @@ export const varchar = (length?: number) =>
     primaryKey: false,
     unique: false,
     references: undefined,
-    ddlType: length === undefined ? "varchar" : `varchar(${length})`,
+    ddlType: length === undefined ? undefined : `varchar(${length})`,
     identity: undefined
   })
 export const char = (length = 1) =>
@@ -114,9 +114,9 @@ export const date = () => primitive(LocalDateStringSchema, standardDatatypes.dat
 export const time = () => primitive(LocalTimeStringSchema, standardDatatypes.time())
 export const datetime = () => primitive(LocalDateTimeStringSchema, standardDatatypes.datetime())
 export const timestamp = () => primitive(LocalDateTimeStringSchema, standardDatatypes.timestamp())
-export const blob = () => primitive(Schema.Uint8ArrayFromSelf, standardDatatypes.blob())
-export const json = <SchemaType extends Schema.Schema.Any>(schema: SchemaType) =>
-  makeColumnDefinition(schema as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
+export const blob = () => primitive(Schema.Uint8Array, standardDatatypes.blob())
+export const json = <SchemaType extends Schema.Top>(schema: SchemaType) =>
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>>, {
     dbType: { ...standardDatatypes.json(), variant: "json" } as Expression.DbType.Json<"standard", "json">,
     nullable: false,
     hasDefault: false,

package/src/standard/datatypes/index.ts

@@ -15,6 +15,7 @@ const withMetadata = <Kind extends keyof typeof standardDatatypeKinds & string>(
     runtime: kindSpec.runtime,
     compareGroup: familySpec?.compareGroup,
     castTargets: familySpec?.castTargets,
+    implicitTargets: (familySpec as { readonly implicitTargets?: readonly string[] }).implicitTargets,
     traits: familySpec?.traits
   }
 }
@@ -76,8 +77,7 @@ export const standardDatatypes = {
   > & {
     readonly uuid: () => StandardUuidWitness
     readonly json: () => StandardJsonWitness
-  }),
-  float8: () => withMetadata("real")
+  })
 }
 
 export type StandardDatatypeModule = typeof standardDatatypes

package/src/standard/datatypes/spec.ts

@@ -1,98 +1,12 @@
-import type { DatatypeFamilySpec, DatatypeKindSpec } from "../../internal/datatypes/shape.js"
+import {
+  portableDatatypeFamilies,
+  portableDatatypeKinds,
+  type PortableDatatypeFamily,
+  type PortableDatatypeKind
+} from "../../internal/datatypes/matrix.js"
 
-export const standardDatatypeFamilies = {
-  text: {
-    compareGroup: "text",
-    castTargets: ["text", "numeric", "integer", "real", "boolean", "date", "time", "datetime", "json", "blob", "null"],
-    traits: {
-      textual: true,
-      ordered: true
-    }
-  },
-  numeric: {
-    compareGroup: "numeric",
-    castTargets: ["numeric", "integer", "real", "text", "boolean", "date", "time", "datetime"],
-    traits: {
-      ordered: true
-    }
-  },
-  integer: {
-    compareGroup: "numeric",
-    castTargets: ["integer", "numeric", "real", "text", "boolean", "date", "time", "datetime"],
-    traits: {
-      ordered: true
-    }
-  },
-  real: {
-    compareGroup: "numeric",
-    castTargets: ["real", "numeric", "integer", "text", "boolean"],
-    traits: {
-      ordered: true
-    }
-  },
-  boolean: {
-    compareGroup: "boolean",
-    castTargets: ["boolean", "integer", "numeric", "text"],
-    traits: {}
-  },
-  date: {
-    compareGroup: "date",
-    castTargets: ["date", "time", "datetime", "text", "numeric", "integer"],
-    traits: {
-      ordered: true
-    }
-  },
-  time: {
-    compareGroup: "time",
-    castTargets: ["time", "date", "datetime", "text", "numeric", "integer"],
-    traits: {
-      ordered: true
-    }
-  },
-  datetime: {
-    compareGroup: "datetime",
-    castTargets: ["datetime", "date", "time", "text", "numeric", "integer"],
-    traits: {
-      ordered: true
-    }
-  },
-  json: {
-    compareGroup: "json",
-    castTargets: ["json", "text"],
-    traits: {}
-  },
-  blob: {
-    compareGroup: "blob",
-    castTargets: ["blob", "text"],
-    traits: {}
-  },
-  null: {
-    compareGroup: "null",
-    castTargets: ["text", "numeric", "integer", "real", "boolean", "date", "time", "datetime", "json", "blob", "null"],
-    traits: {}
-  }
-} as const satisfies Record<string, DatatypeFamilySpec>
+export const standardDatatypeFamilies = portableDatatypeFamilies
+export const standardDatatypeKinds = portableDatatypeKinds
 
-export const standardDatatypeKinds = {
-  text: { family: "text", runtime: "string" },
-  varchar: { family: "text", runtime: "string" },
-  char: { family: "text", runtime: "string" },
-  clob: { family: "text", runtime: "string" },
-  int: { family: "integer", runtime: "number" },
-  integer: { family: "integer", runtime: "number" },
-  bigint: { family: "integer", runtime: "bigintString" },
-  numeric: { family: "numeric", runtime: "decimalString" },
-  decimal: { family: "numeric", runtime: "decimalString" },
-  real: { family: "real", runtime: "number" },
-  double: { family: "real", runtime: "number" },
-  boolean: { family: "boolean", runtime: "boolean" },
-  date: { family: "date", runtime: "localDate" },
-  time: { family: "time", runtime: "localTime" },
-  datetime: { family: "datetime", runtime: "localDateTime" },
-  timestamp: { family: "datetime", runtime: "localDateTime" },
-  json: { family: "json", runtime: "json" },
-  blob: { family: "blob", runtime: "bytes" }
-} as const satisfies Record<string, DatatypeKindSpec>
-
-export type StandardDatatypeFamily = keyof typeof standardDatatypeFamilies
-export type StandardDatatypeKind = keyof typeof standardDatatypeKinds
+export type StandardDatatypeFamily = PortableDatatypeFamily
+export type StandardDatatypeKind = PortableDatatypeKind

package/src/standard/foreign-key.ts

@@ -0,0 +1,37 @@
+import * as BaseTable from "../internal/table.js"
+import type { TableOptionSpec } from "../internal/table-options.js"
+
+type ForeignKeySpec = Extract<TableOptionSpec, { readonly kind: "foreignKey" }>
+
+export type ReferentialAction = BaseTable.ReferentialAction
+
+export const make = BaseTable.foreignKey
+
+export const named = <const Name extends string>(
+  name: BaseTable.NonEmptyStringInput<Name>
+) =>
+  <Spec extends ForeignKeySpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+    option: BaseTable.TableOption<Spec, TableContext>
+  ): BaseTable.TableOption<Spec & { readonly name: Name }, TableContext> =>
+    BaseTable.mapOption(option, (spec) => ({
+      ...spec,
+      name
+    } as Spec & { readonly name: Name }))
+
+export const onDelete = (action: BaseTable.ReferentialAction) =>
+  <Spec extends ForeignKeySpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+    option: BaseTable.TableOption<Spec, TableContext>
+  ): BaseTable.TableOption<Spec & { readonly onDelete: BaseTable.ReferentialAction }, TableContext> =>
+    BaseTable.mapOption(option, (spec) => ({
+      ...spec,
+      onDelete: action
+    } as Spec & { readonly onDelete: BaseTable.ReferentialAction }))
+
+export const onUpdate = (action: BaseTable.ReferentialAction) =>
+  <Spec extends ForeignKeySpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+    option: BaseTable.TableOption<Spec, TableContext>
+  ): BaseTable.TableOption<Spec & { readonly onUpdate: BaseTable.ReferentialAction }, TableContext> =>
+    BaseTable.mapOption(option, (spec) => ({
+      ...spec,
+      onUpdate: action
+    } as Spec & { readonly onUpdate: BaseTable.ReferentialAction }))

package/src/standard/function/temporal.ts

@@ -37,7 +37,7 @@ const makeTemporal = <
 >(
   name: Name,
   dbType: Db,
-  runtimeSchema: Schema.Schema<Runtime, any, any>
+  runtimeSchema: Schema.Schema<Runtime>
 ): TemporalExpression<Runtime, Db, Name> =>
   makeExpression({
     runtime: undefined as unknown as Runtime,

package/src/standard/index.ts

@@ -0,0 +1,17 @@
+import * as BaseTable from "../internal/table.js"
+import type { TableOptionSpec } from "../internal/table-options.js"
+
+type IndexSpec = Extract<TableOptionSpec, { readonly kind: "index" }>
+
+export const make = BaseTable.index
+
+export const named = <const Name extends string>(
+  name: BaseTable.NonEmptyStringInput<Name>
+) =>
+  <Spec extends IndexSpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+    option: BaseTable.TableOption<Spec, TableContext>
+  ): BaseTable.TableOption<Spec & { readonly name: Name }, TableContext> =>
+    BaseTable.mapOption(option, (spec) => ({
+      ...spec,
+      name
+    } as Spec & { readonly name: Name }))