@astrojs/db 0.7.2 → 0.8.0

package/dist/core/schemas.js

@@ -0,0 +1,151 @@
+import { SQL } from "drizzle-orm";
+import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
+import { z } from "zod";
+import { SERIALIZED_SQL_KEY } from "../runtime/types.js";
+import { errorMap } from "./integration/error-map.js";
+const sqlite = new SQLiteAsyncDialect();
+const sqlSchema = z.instanceof(SQL).transform(
+  (sqlObj) => ({
+    [SERIALIZED_SQL_KEY]: true,
+    sql: sqlite.sqlToQuery(sqlObj).sql
+  })
+);
+const baseColumnSchema = z.object({
+  label: z.string().optional(),
+  optional: z.boolean().optional().default(false),
+  unique: z.boolean().optional().default(false),
+  deprecated: z.boolean().optional().default(false),
+  // Defined when `defineReadableTable()` is called
+  name: z.string().optional(),
+  // TODO: rename to `tableName`. Breaking schema change
+  collection: z.string().optional()
+});
+const booleanColumnSchema = z.object({
+  type: z.literal("boolean"),
+  schema: baseColumnSchema.extend({
+    default: z.union([z.boolean(), sqlSchema]).optional()
+  })
+});
+const numberColumnBaseSchema = baseColumnSchema.omit({ optional: true }).and(
+  z.union([
+    z.object({
+      primaryKey: z.literal(false).optional().default(false),
+      optional: baseColumnSchema.shape.optional,
+      default: z.union([z.number(), sqlSchema]).optional()
+    }),
+    z.object({
+      // `integer primary key` uses ROWID as the default value.
+      // `optional` and `default` do not have an effect,
+      // so disable these config options for primary keys.
+      primaryKey: z.literal(true),
+      optional: z.literal(false).optional(),
+      default: z.literal(void 0).optional()
+    })
+  ])
+);
+const numberColumnOptsSchema = numberColumnBaseSchema.and(
+  z.object({
+    references: z.function().returns(z.lazy(() => numberColumnSchema)).optional().transform((fn) => fn?.())
+  })
+);
+const numberColumnSchema = z.object({
+  type: z.literal("number"),
+  schema: numberColumnOptsSchema
+});
+const textColumnBaseSchema = baseColumnSchema.omit({ optional: true }).extend({
+  default: z.union([z.string(), sqlSchema]).optional(),
+  multiline: z.boolean().optional()
+}).and(
+  z.union([
+    z.object({
+      primaryKey: z.literal(false).optional().default(false),
+      optional: baseColumnSchema.shape.optional
+    }),
+    z.object({
+      // text primary key allows NULL values.
+      // NULL values bypass unique checks, which could
+      // lead to duplicate URLs per record in Astro Studio.
+      // disable `optional` for primary keys.
+      primaryKey: z.literal(true),
+      optional: z.literal(false).optional()
+    })
+  ])
+);
+const textColumnOptsSchema = textColumnBaseSchema.and(
+  z.object({
+    references: z.function().returns(z.lazy(() => textColumnSchema)).optional().transform((fn) => fn?.())
+  })
+);
+const textColumnSchema = z.object({
+  type: z.literal("text"),
+  schema: textColumnOptsSchema
+});
+const dateColumnSchema = z.object({
+  type: z.literal("date"),
+  schema: baseColumnSchema.extend({
+    default: z.union([
+      sqlSchema,
+      // transform to ISO string for serialization
+      z.date().transform((d) => d.toISOString())
+    ]).optional()
+  })
+});
+const jsonColumnSchema = z.object({
+  type: z.literal("json"),
+  schema: baseColumnSchema.extend({
+    default: z.unknown().optional()
+  })
+});
+const columnSchema = z.union([
+  booleanColumnSchema,
+  numberColumnSchema,
+  textColumnSchema,
+  dateColumnSchema,
+  jsonColumnSchema
+]);
+const referenceableColumnSchema = z.union([textColumnSchema, numberColumnSchema]);
+const columnsSchema = z.record(columnSchema);
+const indexSchema = z.object({
+  on: z.string().or(z.array(z.string())),
+  unique: z.boolean().optional()
+});
+const foreignKeysSchema = z.object({
+  columns: z.string().or(z.array(z.string())),
+  references: z.function().returns(z.lazy(() => referenceableColumnSchema.or(z.array(referenceableColumnSchema)))).transform((fn) => fn())
+});
+const tableSchema = z.object({
+  columns: columnsSchema,
+  indexes: z.record(indexSchema).optional(),
+  foreignKeys: z.array(foreignKeysSchema).optional(),
+  deprecated: z.boolean().optional().default(false)
+});
+const tablesSchema = z.preprocess((rawTables) => {
+  const tables = z.record(z.any()).parse(rawTables, { errorMap });
+  for (const [tableName, table] of Object.entries(tables)) {
+    const { columns } = z.object({ columns: z.record(z.any()) }).parse(table, { errorMap });
+    for (const [columnName, column] of Object.entries(columns)) {
+      column.schema.name = columnName;
+      column.schema.collection = tableName;
+    }
+  }
+  return rawTables;
+}, z.record(tableSchema));
+const dbConfigSchema = z.object({
+  tables: tablesSchema.optional()
+});
+export {
+  booleanColumnSchema,
+  columnSchema,
+  columnsSchema,
+  dateColumnSchema,
+  dbConfigSchema,
+  indexSchema,
+  jsonColumnSchema,
+  numberColumnOptsSchema,
+  numberColumnSchema,
+  referenceableColumnSchema,
+  tableSchema,
+  tablesSchema,
+  textColumnOptsSchema,
+  textColumnSchema
+};