@supatype/cli 0.1.4 → 0.1.5

package/src/type-extractor.ts

@@ -22,6 +22,7 @@ import {
   type ExtractedSchemaAstV2,
   type ExtractedStorageBucketAst,
   type FieldAstV2,
+  type KernelFieldFacts,
   type ParsedField,
 } from "./schema-ast-v2.js"
 
@@ -410,6 +411,7 @@ function parseFieldType(
     fieldDefault: undefined as string | number | boolean | null | undefined,
     localized: false,
     notLocalized: false,
+    checkConstraint: undefined as string | undefined,
   }
 
   const resolving = new Set<string>()
@@ -481,11 +483,46 @@ function parseFieldType(
         current = valueArg ?? current
         continue
       }
-      case "MaxLength":
-      case "MinLength":
-      case "Between":
+      case "MaxLength": {
+        const max = parseNumericTypeArg(current.typeArguments?.[1], sourceFile)
+        if (max !== undefined) {
+          flags.checkConstraint = mergeCheckConstraint(
+            flags.checkConstraint,
+            `char_length("{name}") <= ${max}`,
+          )
+        }
+        current = current.typeArguments?.[0] ?? current
+        continue
+      }
+      case "MinLength": {
+        const min = parseNumericTypeArg(current.typeArguments?.[1], sourceFile)
+        if (min !== undefined) {
+          flags.checkConstraint = mergeCheckConstraint(
+            flags.checkConstraint,
+            `char_length("{name}") >= ${min}`,
+          )
+        }
+        current = current.typeArguments?.[0] ?? current
+        continue
+      }
+      case "Between": {
+        const min = parseNumericTypeArg(current.typeArguments?.[1], sourceFile)
+        const max = parseNumericTypeArg(current.typeArguments?.[2], sourceFile)
+        if (min !== undefined) {
+          flags.checkConstraint = mergeCheckConstraint(
+            flags.checkConstraint,
+            `"{name}"::numeric >= ${min}`,
+          )
+        }
+        if (max !== undefined) {
+          flags.checkConstraint = mergeCheckConstraint(
+            flags.checkConstraint,
+            `"{name}"::numeric <= ${max}`,
+          )
+        }
         current = current.typeArguments?.[0] ?? current
         continue
+      }
       case "Localized":
         flags.localized = true
         current = current.typeArguments?.[0] ?? current
@@ -494,36 +531,68 @@ function parseFieldType(
         flags.notLocalized = true
         current = current.typeArguments?.[0] ?? current
         continue
-      case "RelatedTo":
+      case "RelatedTo": {
         flags.relationCardinality = "one"
         flags.relationTarget = relationTargetFromTypeArg(current.typeArguments?.[0], sourceFile)
+        const relOpts = parseRelationOptions(current.typeArguments?.[1], sourceFile)
         // `target` must match `ModelAst.name` to satisfy validator resolution.
         // FK column follows the field name (two relations to the same model need distinct columns).
         return emitField({
           kind: "relation",
-          kernel: { cardinality: "belongsTo", target: flags.relationTarget! },
+          kernel: {
+            cardinality: "belongsTo",
+            target: flags.relationTarget!,
+            ...relationOptionsKernel(relOpts),
+          },
           db: { foreignKey: relationForeignKeyFromField(fieldName) },
           platform: flags.editorReadOnly ? { readOnly: true } : {},
         })
-      case "HasOne":
+      }
+      case "HasOne": {
         flags.relationCardinality = "one"
-        flags.relationTarget = current.typeArguments?.[0]?.getText(sourceFile).replace(/\W/g, "") ?? "unknown"
+        flags.relationTarget = relationTargetFromTypeArg(current.typeArguments?.[0], sourceFile)
+        const relOpts = parseRelationOptions(current.typeArguments?.[1], sourceFile)
+        return emitField({
+          kind: "relation",
+          kernel: {
+            cardinality: "hasOne",
+            target: flags.relationTarget,
+            ...relationOptionsKernel(relOpts),
+          },
+          db: {},
+          platform: flags.editorReadOnly ? { readOnly: true } : {},
+        })
+      }
+      case "HasMany": {
+        flags.relationCardinality = "many"
+        flags.relationTarget = relationTargetFromTypeArg(current.typeArguments?.[0], sourceFile)
+        const relOpts = parseRelationOptions(current.typeArguments?.[1], sourceFile)
         return emitField({
           kind: "relation",
-          kernel: { cardinality: "hasOne", target: flags.relationTarget },
+          kernel: {
+            cardinality: "hasMany",
+            target: flags.relationTarget,
+            ...relationOptionsKernel(relOpts),
+          },
           db: {},
           platform: flags.editorReadOnly ? { readOnly: true } : {},
         })
-      case "HasMany":
-      case "ManyToMany":
+      }
+      case "ManyToMany": {
         flags.relationCardinality = "many"
-        flags.relationTarget = current.typeArguments?.[0]?.getText(sourceFile).replace(/\W/g, "") ?? "unknown"
+        flags.relationTarget = relationTargetFromTypeArg(current.typeArguments?.[0], sourceFile)
+        const relOpts = parseRelationOptions(current.typeArguments?.[1], sourceFile)
         return emitField({
           kind: "relation",
-          kernel: { cardinality: "hasMany", target: flags.relationTarget },
+          kernel: {
+            cardinality: "manyToMany",
+            target: flags.relationTarget,
+            ...relationOptionsKernel(relOpts),
+          },
           db: {},
           platform: flags.editorReadOnly ? { readOnly: true } : {},
         })
+      }
       default: {
         const resolved = tryResolveTypeReference(current, sourceFile, resolveCtx, { fieldName, resolving })
         if (resolved) {
@@ -642,6 +711,13 @@ function parseFieldType(
     parsed = { ...parsed, kernel }
   }
 
+  if (flags.checkConstraint !== undefined) {
+    parsed = {
+      ...parsed,
+      kernel: { ...parsed.kernel, check: flags.checkConstraint },
+    }
+  }
+
   return emitField(finalizeParsedField(parsed, flags, context))
 }
 
@@ -1534,7 +1610,7 @@ function parseModelIndexes(
   const indexes: unknown[] = []
   for (const element of indexesProp.type.elements) {
     if (!ts.isTypeLiteralNode(element)) continue
-    const indexDef: Record<string, unknown> = { using: "btree" }
+    const indexDef: Record<string, unknown> = { using: "btree", unique: false }
     for (const member of element.members) {
       if (!ts.isPropertySignature(member) || !member.type) continue
       const key = getPropertyName(member.name)
@@ -1628,6 +1704,73 @@ function parseAccessRule(typeNode: ts.TypeNode, sourceFile: ts.SourceFile): Reco
   }
 }
 
+interface ParsedRelationOptions {
+  required?: boolean
+  onDelete?: string
+  onUpdate?: string
+  through?: string
+}
+
+function parseRelationOptions(
+  optsArg: ts.TypeNode | undefined,
+  sourceFile: ts.SourceFile,
+): ParsedRelationOptions {
+  const out: ParsedRelationOptions = {}
+  if (!optsArg || !ts.isTypeLiteralNode(optsArg)) return out
+
+  for (const member of optsArg.members) {
+    if (!ts.isPropertySignature(member) || !member.name || !member.type) continue
+    const key = getPropertyName(member.name)
+    if (!key) continue
+
+    if (key === "required" && isBooleanLiteralType(member.type, true)) {
+      out.required = true
+      continue
+    }
+
+    if (
+      (key === "onDelete" || key === "onUpdate" || key === "through") &&
+      ts.isLiteralTypeNode(member.type) &&
+      ts.isStringLiteral(member.type.literal)
+    ) {
+      out[key] = member.type.literal.text
+    }
+  }
+
+  return out
+}
+
+function relationOptionsKernel(
+  opts: ParsedRelationOptions,
+): Pick<KernelFieldFacts, "required" | "onDelete" | "onUpdate" | "through"> {
+  return {
+    ...(opts.required === true && { required: true }),
+    ...(opts.onDelete !== undefined && { onDelete: opts.onDelete }),
+    ...(opts.onUpdate !== undefined && { onUpdate: opts.onUpdate }),
+    ...(opts.through !== undefined && { through: opts.through }),
+  }
+}
+
+function parseNumericTypeArg(typeArg: ts.TypeNode | undefined, sourceFile: ts.SourceFile): number | undefined {
+  if (!typeArg) return undefined
+  if (ts.isLiteralTypeNode(typeArg) && ts.isNumericLiteral(typeArg.literal)) {
+    const value = Number(typeArg.literal.text)
+    return Number.isFinite(value) ? value : undefined
+  }
+  if (ts.isLiteralTypeNode(typeArg) && ts.isStringLiteral(typeArg.literal)) {
+    const value = Number(typeArg.literal.text)
+    return Number.isFinite(value) ? value : undefined
+  }
+  const raw = typeArg.getText(sourceFile).trim()
+  const value = Number(raw)
+  return Number.isFinite(value) ? value : undefined
+}
+
+function mergeCheckConstraint(existing: string | undefined, next: string): string {
+  if (!existing) return next
+  return `(${existing}) AND (${next})`
+}
+
 function relationTargetFromTypeArg(typeArg: ts.TypeNode | undefined, sourceFile: ts.SourceFile): string {
   if (!typeArg) return "unknown"
   const raw = typeArg.getText(sourceFile).replace(/\s/g, "")

package/tests/realtime-launch.test.ts

@@ -0,0 +1,25 @@
+import { mkdtempSync, rmSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { describe, expect, it } from "vitest"
+import { resolveRealtimeLaunch } from "../src/realtime-launch.js"
+import type { SupatypeProjectConfig } from "../src/project-config.js"
+
+describe("resolveRealtimeLaunch", () => {
+  it("uses overrides.realtime .js entry via node", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-rt-launch-"))
+    try {
+      const entry = join(dir, "fake-realtime.js")
+      const { writeFileSync } = await import("node:fs")
+      writeFileSync(entry, "export {}\n")
+      const config = {
+        overrides: { realtime: entry },
+      } as SupatypeProjectConfig
+      const spec = await resolveRealtimeLaunch(config, dir)
+      expect(spec.bin).toBe(process.execPath)
+      expect(spec.args).toEqual([entry])
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+})

package/tests/required-host-components.test.ts

@@ -33,6 +33,7 @@ describe("requiredHostComponents", () => {
       "engine",
       "server",
       "postgres",
+      "realtime",
     ])
     rmSync(dir, { recursive: true, force: true })
   })
@@ -44,6 +45,7 @@ describe("requiredHostComponents", () => {
       "engine",
       "server",
       "postgres",
+      "realtime",
       "deno",
     ])
     rmSync(dir, { recursive: true, force: true })

package/tests/route-manifest.test.ts

@@ -0,0 +1,29 @@
+import { mkdtempSync, readFileSync, rmSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { describe, expect, it } from "vitest"
+import { patchRouteManifest } from "../src/route-manifest.js"
+
+describe("patchRouteManifest", () => {
+  it("merges realtime fields into existing manifest", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-manifest-"))
+    const path = join(dir, "manifest.json")
+    try {
+      patchRouteManifest(path, { realtime_enabled: true, realtime_url: "http://127.0.0.1:4000" })
+      const parsed = JSON.parse(readFileSync(path, "utf8")) as Record<string, unknown>
+      expect(parsed).toMatchObject({
+        realtime_enabled: true,
+        realtime_url: "http://127.0.0.1:4000",
+      })
+      patchRouteManifest(path, { schema: "public" })
+      const again = JSON.parse(readFileSync(path, "utf8")) as Record<string, unknown>
+      expect(again).toMatchObject({
+        schema: "public",
+        realtime_enabled: true,
+        realtime_url: "http://127.0.0.1:4000",
+      })
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+})

package/tests/type-extractor.test.ts

@@ -635,6 +635,7 @@ export type Message = Model<{
       kind: "relation",
       cardinality: "belongsTo",
       target: "Profile",
+      required: true,
       annotations: { db: { foreignKey: "created_by_id" } },
     })
     expect(room?.fields["created_at"]).toMatchObject({ kind: "datetime" })
@@ -647,12 +648,63 @@ export type Message = Model<{
       kind: "relation",
       cardinality: "belongsTo",
       target: "Room",
+      required: true,
+      onDelete: "cascade",
       annotations: { db: { foreignKey: "room_id" } },
     })
     expect(message?.fields["author"]).toMatchObject({
       kind: "relation",
       cardinality: "belongsTo",
       target: "Profile",
+      required: true,
+    })
+    expect(message?.fields["body"]).toMatchObject({
+      kind: "text",
+      check: 'char_length("{name}") <= 2000',
+    })
+    const messageIndexes = message?.annotations.db.indexes as Array<Record<string, unknown>>
+    expect(messageIndexes).toHaveLength(1)
+    expect(messageIndexes?.[0]).toMatchObject({
+      using: "btree",
+      unique: false,
+      fields: ["room_id", "created_at"],
+    })
+  })
+
+  it("extracts ManyToMany relations with through table option", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-many-to-many-"))
+    dirs.push(dir)
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type { Model, UUID, ManyToMany, Public, LoggedIn } from "@supatype/types"
+
+export type Course = Model<{
+  id: UUID
+  title: string
+}, {
+  access: { read: Public; create: LoggedIn }
+}>
+
+export type Student = Model<{
+  id: UUID
+  name: string
+  courses: ManyToMany<Course, { through: "enrollments" }>
+}, {
+  access: { read: Public; create: LoggedIn }
+}>
+`,
+      "utf8",
+    )
+
+    const ast = extractSchemaAstFromTypes(schemaPath, dir)
+    const student = ast?.models.find((m) => m.name === "Student")
+    expect(student?.fields["courses"]).toMatchObject({
+      kind: "relation",
+      cardinality: "manyToMany",
+      target: "Course",
+      through: "enrollments",
     })
   })