effect-qb 0.12.3

package/src/mysql/table.ts

@@ -0,0 +1,157 @@
+import type * as Schema from "effect/Schema"
+
+import type * as Expression from "../internal/expression.js"
+import { ColumnTypeId, type AnyColumnDefinition } from "../internal/column-state.js"
+import * as BaseTable from "../internal/table.js"
+
+type Dialect = "mysql"
+
+type DialectColumn = AnyColumnDefinition & {
+  readonly [ColumnTypeId]: {
+    readonly dbType: Expression.DbType.Any & { readonly dialect: Dialect }
+  }
+}
+
+type DialectFieldMap = Record<string, DialectColumn>
+
+type InlinePrimaryKeyKeys<Fields extends DialectFieldMap> = Extract<{
+  [K in keyof Fields]: Fields[K]["metadata"]["primaryKey"] extends true ? K : never
+}[keyof Fields], string>
+
+export type TableDefinition<
+  Name extends string,
+  Fields extends DialectFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>,
+  Kind extends "schema" | "alias" = "schema",
+  SchemaName extends string | undefined = undefined
+> = BaseTable.TableDefinition<Name, Fields, PrimaryKeyColumns, Kind, SchemaName>
+
+export type TableClassStatic<
+  Name extends string,
+  Fields extends DialectFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>,
+  SchemaName extends string | undefined = undefined
+> = BaseTable.TableClassStatic<Name, Fields, PrimaryKeyColumns, SchemaName>
+
+export type AnyTable = BaseTable.AnyTable
+
+type FieldsOfTable<Table> = Table extends BaseTable.TableDefinition<any, infer Fields extends DialectFieldMap, any, any, any>
+  ? Fields
+  : Table extends BaseTable.TableClassStatic<any, infer Fields extends DialectFieldMap, any, any>
+    ? Fields
+    : never
+
+type PrimaryKeyOfTable<Table> = Table extends BaseTable.TableDefinition<any, any, infer PrimaryKeyColumns extends string, any, any>
+  ? PrimaryKeyColumns
+  : Table extends BaseTable.TableClassStatic<any, any, infer PrimaryKeyColumns extends string, any>
+    ? PrimaryKeyColumns
+    : never
+
+type SchemaNameOfTable<Table> = Table extends BaseTable.TableDefinition<any, any, any, any, infer SchemaName>
+  ? SchemaName
+  : Table extends BaseTable.TableClassStatic<any, any, any, infer SchemaName>
+    ? SchemaName
+    : never
+
+export type TableSchemaNamespace<SchemaName extends string> = {
+  readonly schemaName: SchemaName
+  readonly table: <
+    Name extends string,
+    Fields extends DialectFieldMap,
+    PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>
+  >(
+    name: Name,
+    fields: Fields,
+    ...options: BaseTable.DeclaredTableOptions
+  ) => TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>
+}
+
+export type TableOption = BaseTable.TableOption
+
+export const TypeId = BaseTable.TypeId
+export const OptionsSymbol = BaseTable.OptionsSymbol
+export const options = BaseTable.options
+
+export const make = <
+  Name extends string,
+  Fields extends DialectFieldMap,
+  SchemaName extends string | undefined = undefined
+>(
+  name: Name,
+  fields: Fields,
+  schemaName: SchemaName = undefined as SchemaName
+): TableDefinition<Name, Fields> =>
+  BaseTable.make(name, fields, schemaName) as TableDefinition<Name, Fields>
+
+export const schema = <SchemaName extends string>(
+  schemaName: SchemaName
+): TableSchemaNamespace<SchemaName> => ({
+  schemaName,
+  table: <
+    Name extends string,
+    Fields extends DialectFieldMap,
+    PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>
+  >(
+    name: Name,
+    fields: Fields,
+    ...declaredOptions: BaseTable.DeclaredTableOptions
+  ) =>
+    BaseTable.schema(schemaName).table(
+      name,
+      fields,
+      ...declaredOptions
+    ) as TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>
+})
+
+export const alias = <
+  Table extends AnyTable,
+  AliasName extends string
+>(
+  table: Table,
+  aliasName: AliasName
+): TableDefinition<
+  AliasName,
+  FieldsOfTable<Table>,
+  PrimaryKeyOfTable<Table>,
+  "alias",
+  SchemaNameOfTable<Table>
+> =>
+  BaseTable.alias(table as any, aliasName) as TableDefinition<
+    AliasName,
+    FieldsOfTable<Table>,
+    PrimaryKeyOfTable<Table>,
+    "alias",
+    SchemaNameOfTable<Table>
+  >
+
+export const Class = <Self = never, SchemaName extends string | undefined = undefined>(
+  name: string,
+  schemaName: SchemaName = undefined as SchemaName
+) => {
+  const base = BaseTable.Class<Self, SchemaName>(name, schemaName)
+  return base as unknown as <
+    Fields extends DialectFieldMap
+  >(fields: Fields) => [Self] extends [never]
+    ? BaseTable.MissingSelfGeneric
+    : TableClassStatic<typeof name, Fields, InlinePrimaryKeyKeys<Fields>, SchemaName>
+}
+
+export const primaryKey = BaseTable.primaryKey
+export const unique = BaseTable.unique
+export const index = BaseTable.index
+export const foreignKey = <
+  LocalColumns extends string | readonly string[],
+  TargetTable extends AnyTable,
+  TargetColumns extends string | readonly string[]
+>(
+  columns: LocalColumns,
+  target: () => TargetTable,
+  referencedColumns: TargetColumns
+): BaseTable.TableOption =>
+  BaseTable.foreignKey(columns, target as () => BaseTable.AnyTable, referencedColumns)
+
+export const check = BaseTable.check
+
+export type SelectOf<Table extends { readonly schemas: { readonly select: Schema.Schema<any> } }> = BaseTable.SelectOf<Table>
+export type InsertOf<Table extends { readonly schemas: { readonly insert: Schema.Schema<any> } }> = BaseTable.InsertOf<Table>
+export type UpdateOf<Table extends { readonly schemas: { readonly update: Schema.Schema<any> } }> = BaseTable.UpdateOf<Table>

package/src/mysql.ts

@@ -0,0 +1,18 @@
+/** MySQL-specialized column-definition DSL. */
+export * as Column from "./mysql/column.js"
+/** MySQL datatype witnesses and coercion families. */
+export * as Datatypes from "./mysql/datatypes/index.js"
+/** MySQL error catalog and error normalization helpers. */
+export * as Errors from "./mysql/errors/index.js"
+/** Shared scalar SQL expression interfaces and DB-type descriptors. */
+export * as Expression from "./internal/expression.js"
+/** MySQL-specialized typed query execution contracts. */
+export * as Executor from "./mysql/executor.js"
+/** Shared logical query-plan interfaces. */
+export * as Plan from "./internal/plan.js"
+/** MySQL-specialized query-construction DSL. */
+export * as Query from "./mysql/query.js"
+/** MySQL-specialized table-definition DSL. */
+export * as Table from "./mysql/table.js"
+/** MySQL-specialized built-in renderer entrypoint. */
+export * as Renderer from "./mysql/renderer.js"

package/src/postgres/column.ts

@@ -0,0 +1,20 @@
+export {
+  boolean,
+  date,
+  generated,
+  hasDefault,
+  int,
+  json,
+  nullable,
+  number,
+  primaryKey,
+  references,
+  schema,
+  text,
+  timestamp,
+  custom,
+  unique,
+  uuid
+} from "../internal/column.js"
+
+export type { Any, AnyBound } from "../internal/column.js"

package/src/postgres/datatypes/index.ts

@@ -0,0 +1,8 @@
+import { makeDatatypeModule } from "../../internal/datatypes/define.js"
+import { postgresDatatypeKinds } from "./spec.js"
+
+export const postgresDatatypes = makeDatatypeModule("postgres", postgresDatatypeKinds, {
+  boolean: "bool"
+})
+
+export type PostgresDatatypeModule = typeof postgresDatatypes

package/src/postgres/datatypes/spec.ts

@@ -0,0 +1,264 @@
+import type { DatatypeFamilySpec, DatatypeKindSpec } from "../../internal/datatypes/shape.js"
+
+export const postgresDatatypeFamilies = {
+  text: {
+    compareGroup: "text",
+    castTargets: [
+      "text",
+      "numeric",
+      "boolean",
+      "date",
+      "time",
+      "timestamp",
+      "interval",
+      "binary",
+      "uuid",
+      "json",
+      "xml",
+      "bit",
+      "oid",
+      "identifier",
+      "network",
+      "spatial",
+      "textsearch",
+      "range",
+      "multirange",
+      "array",
+      "money",
+      "null"
+    ],
+    traits: {
+      textual: true,
+      ordered: true
+    }
+  },
+  numeric: {
+    compareGroup: "numeric",
+    castTargets: ["numeric", "text", "boolean", "date", "time", "timestamp", "interval", "uuid", "bit", "oid", "money"],
+    traits: {
+      ordered: true
+    }
+  },
+  boolean: {
+    compareGroup: "boolean",
+    castTargets: ["boolean", "text", "numeric"],
+    traits: {}
+  },
+  date: {
+    compareGroup: "date",
+    castTargets: ["date", "timestamp", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  time: {
+    compareGroup: "time",
+    castTargets: ["time", "timestamp", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  timestamp: {
+    compareGroup: "timestamp",
+    castTargets: ["timestamp", "date", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  interval: {
+    compareGroup: "interval",
+    castTargets: ["interval", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  binary: {
+    compareGroup: "binary",
+    castTargets: ["binary", "text"],
+    traits: {}
+  },
+  uuid: {
+    compareGroup: "uuid",
+    castTargets: ["uuid", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  json: {
+    compareGroup: "json",
+    castTargets: ["json", "text"],
+    traits: {}
+  },
+  xml: {
+    compareGroup: "xml",
+    castTargets: ["xml", "text"],
+    traits: {}
+  },
+  bit: {
+    compareGroup: "bit",
+    castTargets: ["bit", "text", "numeric"],
+    traits: {}
+  },
+  oid: {
+    compareGroup: "oid",
+    castTargets: ["oid", "text", "numeric"],
+    traits: {
+      ordered: true
+    }
+  },
+  identifier: {
+    compareGroup: "identifier",
+    castTargets: ["identifier", "text"],
+    traits: {}
+  },
+  network: {
+    compareGroup: "network",
+    castTargets: ["network", "text"],
+    traits: {}
+  },
+  spatial: {
+    compareGroup: "spatial",
+    castTargets: ["spatial", "text"],
+    traits: {}
+  },
+  textsearch: {
+    compareGroup: "textsearch",
+    castTargets: ["textsearch", "text"],
+    traits: {}
+  },
+  range: {
+    compareGroup: "range",
+    castTargets: ["range", "text"],
+    traits: {}
+  },
+  multirange: {
+    compareGroup: "multirange",
+    castTargets: ["multirange", "text"],
+    traits: {}
+  },
+  enum: {
+    compareGroup: "enum",
+    castTargets: ["enum", "text"],
+    traits: {
+      textual: true,
+      ordered: true
+    }
+  },
+  record: {
+    compareGroup: "record",
+    castTargets: ["record", "text"],
+    traits: {}
+  },
+  array: {
+    compareGroup: "array",
+    castTargets: ["array", "text"],
+    traits: {}
+  },
+  money: {
+    compareGroup: "money",
+    castTargets: ["money", "text", "numeric"],
+    traits: {
+      ordered: true
+    }
+  },
+  null: {
+    compareGroup: "null",
+    castTargets: [
+      "text",
+      "numeric",
+      "boolean",
+      "date",
+      "time",
+      "timestamp",
+      "interval",
+      "binary",
+      "uuid",
+      "json",
+      "xml",
+      "bit",
+      "oid",
+      "identifier",
+      "network",
+      "spatial",
+      "textsearch",
+      "range",
+      "multirange",
+      "array",
+      "money",
+      "null"
+    ],
+    traits: {}
+  }
+} as const satisfies Record<string, DatatypeFamilySpec>
+
+export const postgresDatatypeKinds = {
+  text: { family: "text", runtime: "string" },
+  varchar: { family: "text", runtime: "string" },
+  char: { family: "text", runtime: "string" },
+  citext: { family: "text", runtime: "string" },
+  name: { family: "text", runtime: "string" },
+  uuid: { family: "uuid", runtime: "string" },
+  int2: { family: "numeric", runtime: "number" },
+  int4: { family: "numeric", runtime: "number" },
+  int8: { family: "numeric", runtime: "bigintString" },
+  numeric: { family: "numeric", runtime: "decimalString" },
+  float4: { family: "numeric", runtime: "number" },
+  float8: { family: "numeric", runtime: "number" },
+  money: { family: "money", runtime: "number" },
+  bool: { family: "boolean", runtime: "boolean" },
+  date: { family: "date", runtime: "localDate" },
+  time: { family: "time", runtime: "localTime" },
+  timetz: { family: "time", runtime: "offsetTime" },
+  timestamp: { family: "timestamp", runtime: "localDateTime" },
+  timestamptz: { family: "timestamp", runtime: "instant" },
+  interval: { family: "interval", runtime: "string" },
+  bytea: { family: "binary", runtime: "bytes" },
+  json: { family: "json", runtime: "json" },
+  jsonb: { family: "json", runtime: "json" },
+  xml: { family: "xml", runtime: "string" },
+  bit: { family: "bit", runtime: "string" },
+  varbit: { family: "bit", runtime: "string" },
+  oid: { family: "oid", runtime: "number" },
+  xid: { family: "oid", runtime: "number" },
+  xid8: { family: "oid", runtime: "bigintString" },
+  cid: { family: "oid", runtime: "number" },
+  tid: { family: "identifier", runtime: "string" },
+  regclass: { family: "identifier", runtime: "string" },
+  regtype: { family: "identifier", runtime: "string" },
+  regproc: { family: "identifier", runtime: "string" },
+  regprocedure: { family: "identifier", runtime: "string" },
+  regoper: { family: "identifier", runtime: "string" },
+  regoperator: { family: "identifier", runtime: "string" },
+  regconfig: { family: "identifier", runtime: "string" },
+  regdictionary: { family: "identifier", runtime: "string" },
+  pg_lsn: { family: "identifier", runtime: "string" },
+  txid_snapshot: { family: "identifier", runtime: "string" },
+  inet: { family: "network", runtime: "string" },
+  cidr: { family: "network", runtime: "string" },
+  macaddr: { family: "network", runtime: "string" },
+  macaddr8: { family: "network", runtime: "string" },
+  point: { family: "spatial", runtime: "unknown" },
+  line: { family: "spatial", runtime: "unknown" },
+  lseg: { family: "spatial", runtime: "unknown" },
+  box: { family: "spatial", runtime: "unknown" },
+  path: { family: "spatial", runtime: "unknown" },
+  polygon: { family: "spatial", runtime: "unknown" },
+  circle: { family: "spatial", runtime: "unknown" },
+  tsvector: { family: "textsearch", runtime: "string" },
+  tsquery: { family: "textsearch", runtime: "string" },
+  int4range: { family: "range", runtime: "unknown" },
+  int8range: { family: "range", runtime: "unknown" },
+  numrange: { family: "range", runtime: "unknown" },
+  tsrange: { family: "range", runtime: "unknown" },
+  tstzrange: { family: "range", runtime: "unknown" },
+  daterange: { family: "range", runtime: "unknown" },
+  int4multirange: { family: "multirange", runtime: "unknown" },
+  int8multirange: { family: "multirange", runtime: "unknown" },
+  nummultirange: { family: "multirange", runtime: "unknown" },
+  tsmultirange: { family: "multirange", runtime: "unknown" },
+  tstzmultirange: { family: "multirange", runtime: "unknown" },
+  datemultirange: { family: "multirange", runtime: "unknown" }
+} as const satisfies Record<string, DatatypeKindSpec>
+
+export type PostgresDatatypeFamily = keyof typeof postgresDatatypeFamilies
+export type PostgresDatatypeKind = keyof typeof postgresDatatypeKinds