@astrojs/db 0.7.2 → 0.8.1

package/dist/core/types.js

@@ -1,143 +0,0 @@
-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 {
-  columnSchema,
-  dbConfigSchema,
-  indexSchema,
-  referenceableColumnSchema,
-  tableSchema,
-  tablesSchema
-};

package/dist/core/utils.js

@@ -9,7 +9,7 @@ function getRemoteDatabaseUrl() {
 }
 function getAstroStudioUrl() {
   const env = getAstroStudioEnv();
-  return env.ASTRO_STUDIO_URL || "https://stardate.astro.build";
+  return env.ASTRO_STUDIO_URL || "https://studio.astro.build";
 }
 function getDbDirectoryUrl(root) {
   return new URL("db/", root);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/db",
-  "version": "0.7.2",
+  "version": "0.8.1",
   "description": "",
   "license": "MIT",
   "type": "module",
@@ -23,6 +23,10 @@
     "./dist/runtime/config.js": {
       "import": "./dist/runtime/config.js"
     },
+    "./types": {
+      "types": "./dist/core/types.d.ts",
+      "import": "./dist/core/types.js"
+    },
     "./package.json": "./package.json"
   },
   "typesVersions": {
@@ -30,6 +34,9 @@
       ".": [
         "./index.d.ts"
       ],
+      "types": [
+        "./dist/types.d.ts"
+      ],
       "utils": [
         "./dist/utils.d.ts"
       ],
@@ -73,11 +80,12 @@
     "mocha": "^10.2.0",
     "typescript": "^5.2.2",
     "vite": "^5.1.4",
-    "astro": "4.5.1",
+    "astro": "4.5.2",
     "astro-scripts": "0.0.14"
   },
   "scripts": {
-    "build": "astro-scripts build \"src/**/*.ts\" && tsc",
+    "types:config": "tsc -p ./tsconfig.config-types.json",
+    "build": "astro-scripts build \"src/**/*.ts\" && tsc && pnpm types:config",
     "build:ci": "astro-scripts build \"src/**/*.ts\"",
     "dev": "astro-scripts dev \"src/**/*.ts\"",
     "test": "mocha --exit --timeout 20000 \"test/*.js\" \"test/unit/**/*.js\"",

package/virtual.d.ts

@@ -1,9 +1,33 @@
 declare module 'astro:db' {
-	export const sql: typeof import('./dist/runtime/config.js').sql;
-	export const NOW: typeof import('./dist/runtime/config.js').NOW;
-	export const TRUE: typeof import('./dist/runtime/config.js').TRUE;
-	export const FALSE: typeof import('./dist/runtime/config.js').FALSE;
-	export const column: typeof import('./dist/runtime/config.js').column;
-	export const defineDb: typeof import('./dist/runtime/config.js').defineDb;
-	export const defineTable: typeof import('./dist/runtime/config.js').defineTable;
+	type RuntimeConfig = typeof import('./dist/_internal/runtime/config.js');
+
+	export const sql: RuntimeConfig['sql'];
+	export const NOW: RuntimeConfig['NOW'];
+	export const TRUE: RuntimeConfig['TRUE'];
+	export const FALSE: RuntimeConfig['FALSE'];
+	export const column: RuntimeConfig['column'];
+	export const defineDb: RuntimeConfig['defineDb'];
+	export const defineTable: RuntimeConfig['defineTable'];
+
+	export const eq: RuntimeConfig['eq'];
+	export const gt: RuntimeConfig['gt'];
+	export const gte: RuntimeConfig['gte'];
+	export const lt: RuntimeConfig['lt'];
+	export const lte: RuntimeConfig['lte'];
+	export const ne: RuntimeConfig['ne'];
+	export const isNull: RuntimeConfig['isNull'];
+	export const isNotNull: RuntimeConfig['isNotNull'];
+	export const inArray: RuntimeConfig['inArray'];
+	export const notInArray: RuntimeConfig['notInArray'];
+	export const exists: RuntimeConfig['exists'];
+	export const notExists: RuntimeConfig['notExists'];
+	export const between: RuntimeConfig['between'];
+	export const notBetween: RuntimeConfig['notBetween'];
+	export const like: RuntimeConfig['like'];
+	export const notIlike: RuntimeConfig['notIlike'];
+	export const not: RuntimeConfig['not'];
+	export const asc: RuntimeConfig['asc'];
+	export const desc: RuntimeConfig['desc'];
+	export const and: RuntimeConfig['and'];
+	export const or: RuntimeConfig['or'];
 }