@astrojs/db 0.2.2 → 0.3.1

package/dist/core/types.js

@@ -1,36 +1,100 @@
+import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
+import { collectionToTable } from "../runtime/index.js";
 import { z } from "zod";
+import { SQL } from "drizzle-orm";
+import { errorMap } from "./integration/error-map.js";
+import { SERIALIZED_SQL_KEY } from "../runtime/types.js";
+const sqlite = new SQLiteAsyncDialect();
+const sqlSchema = z.instanceof(SQL).transform(
+  (sqlObj) => ({
+    [SERIALIZED_SQL_KEY]: true,
+    sql: sqlite.sqlToQuery(sqlObj).sql
+  })
+);
 const baseFieldSchema = z.object({
   label: z.string().optional(),
   optional: z.boolean().optional(),
-  unique: z.boolean().optional()
+  unique: z.boolean().optional(),
+  // Defined when `defineCollection()` is called
+  name: z.string().optional(),
+  collection: z.string().optional()
 });
-const booleanFieldSchema = baseFieldSchema.extend({
+const booleanFieldSchema = z.object({
   type: z.literal("boolean"),
-  default: z.boolean().optional()
+  schema: baseFieldSchema.extend({
+    default: z.union([z.boolean(), sqlSchema]).optional()
+  })
 });
-const numberFieldSchema = baseFieldSchema.extend({
+const numberFieldBaseSchema = baseFieldSchema.omit({ optional: true }).and(
+  z.union([
+    z.object({
+      primaryKey: z.literal(false).optional(),
+      optional: z.boolean().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 numberFieldOptsSchema = numberFieldBaseSchema.and(
+  z.object({
+    references: z.function().returns(z.lazy(() => numberFieldSchema)).optional().transform((fn) => fn?.())
+  })
+);
+const numberFieldSchema = z.object({
   type: z.literal("number"),
-  default: z.number().optional(),
-  primaryKey: z.boolean().optional()
+  schema: numberFieldOptsSchema
 });
-const textFieldSchema = baseFieldSchema.extend({
+const textFieldBaseSchema = baseFieldSchema.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(),
+      optional: z.boolean().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 textFieldOptsSchema = textFieldBaseSchema.and(
+  z.object({
+    references: z.function().returns(z.lazy(() => textFieldSchema)).optional().transform((fn) => fn?.())
+  })
+);
+const textFieldSchema = z.object({
   type: z.literal("text"),
-  multiline: z.boolean().optional(),
-  default: z.string().optional(),
-  primaryKey: z.boolean().optional()
+  schema: textFieldOptsSchema
 });
-const dateFieldSchema = baseFieldSchema.extend({
+const dateFieldSchema = z.object({
   type: z.literal("date"),
-  default: z.union([
-    z.literal("now"),
-    // allow date-like defaults in user config,
-    // transform to ISO string for D1 storage
-    z.coerce.date().transform((d) => d.toISOString())
-  ]).optional()
+  schema: baseFieldSchema.extend({
+    default: z.union([
+      sqlSchema,
+      // allow date-like defaults in user config,
+      // transform to ISO string for D1 storage
+      z.coerce.date().transform((d) => d.toISOString())
+    ]).optional()
+  })
 });
-const jsonFieldSchema = baseFieldSchema.extend({
+const jsonFieldSchema = z.object({
   type: z.literal("json"),
-  default: z.unknown().optional()
+  schema: baseFieldSchema.extend({
+    default: z.unknown().optional()
+  })
 });
 const fieldSchema = z.union([
   booleanFieldSchema,
@@ -39,17 +103,20 @@ const fieldSchema = z.union([
   dateFieldSchema,
   jsonFieldSchema
 ]);
+const referenceableFieldSchema = z.union([textFieldSchema, numberFieldSchema]);
 const fieldsSchema = z.record(fieldSchema);
 const indexSchema = z.object({
   on: z.string().or(z.array(z.string())),
   unique: z.boolean().optional()
 });
-const indexesSchema = z.record(indexSchema);
+const foreignKeysSchema = z.object({
+  fields: z.string().or(z.array(z.string())),
+  references: z.function().returns(z.lazy(() => referenceableFieldSchema.or(z.array(referenceableFieldSchema)))).transform((fn) => fn())
+});
 const baseCollectionSchema = z.object({
   fields: fieldsSchema,
-  indexes: indexesSchema.optional(),
-  table: z.any(),
-  _setMeta: z.function().optional()
+  indexes: z.record(indexSchema).optional(),
+  foreignKeys: z.array(foreignKeysSchema).optional()
 });
 const readableCollectionSchema = baseCollectionSchema.extend({
   writable: z.literal(false)
@@ -58,7 +125,24 @@ const writableCollectionSchema = baseCollectionSchema.extend({
   writable: z.literal(true)
 });
 const collectionSchema = z.union([readableCollectionSchema, writableCollectionSchema]);
-const collectionsSchema = z.record(collectionSchema);
+const collectionsSchema = z.preprocess((rawCollections) => {
+  const collections = z.record(z.any()).parse(rawCollections, { errorMap });
+  for (const [collectionName, collection] of Object.entries(collections)) {
+    collection.table = collectionToTable(
+      collectionName,
+      collectionSchema.parse(collection, { errorMap })
+    );
+    const { fields } = z.object({ fields: z.record(z.any()) }).parse(collection, { errorMap });
+    for (const [fieldName, field2] of Object.entries(fields)) {
+      field2.schema.name = fieldName;
+      field2.schema.collection = collectionName;
+    }
+  }
+  return rawCollections;
+}, z.record(collectionSchema));
+function defineData(fn) {
+  return fn;
+}
 const dbConfigSchema = z.object({
   studio: z.boolean().optional(),
   collections: collectionsSchema.optional(),
@@ -67,57 +151,44 @@ const dbConfigSchema = z.object({
 const astroConfigWithDbSchema = z.object({
   db: dbConfigSchema.optional()
 });
-function defineCollection(userConfig) {
-  const meta = { table: null };
-  function _setMeta(values) {
-    Object.assign(meta, values);
-  }
+function baseDefineCollection(userConfig, writable) {
   return {
     ...userConfig,
-    writable: false,
-    get table() {
-      return meta.table;
-    },
-    // @ts-expect-error private field
-    _setMeta
+    writable,
+    // set at runtime to get the table name
+    table: null
   };
 }
+function defineCollection(userConfig) {
+  return baseDefineCollection(userConfig, false);
+}
 function defineWritableCollection(userConfig) {
-  const meta = { table: null };
-  function _setMeta(values) {
-    Object.assign(meta, values);
-  }
+  return baseDefineCollection(userConfig, true);
+}
+function createField(type, schema) {
   return {
-    ...userConfig,
-    writable: true,
-    get table() {
-      return meta.table;
-    },
-    // @ts-expect-error private field
-    _setMeta
+    type,
+    /**
+     * @internal
+     */
+    schema
   };
 }
-const baseDefaults = {
-  optional: false,
-  unique: false,
-  label: void 0,
-  default: void 0
-};
 const field = {
-  number(opts = {}) {
-    return { type: "number", ...baseDefaults, ...opts };
+  number: (opts = {}) => {
+    return createField("number", opts);
   },
-  boolean(opts = {}) {
-    return { type: "boolean", ...baseDefaults, ...opts };
+  boolean: (opts = {}) => {
+    return createField("boolean", opts);
   },
-  text(opts = {}) {
-    return { type: "text", multiline: false, ...baseDefaults, ...opts };
+  text: (opts = {}) => {
+    return createField("text", opts);
   },
   date(opts = {}) {
-    return { type: "date", ...baseDefaults, ...opts };
+    return createField("date", opts);
   },
   json(opts = {}) {
-    return { type: "json", ...baseDefaults, ...opts };
+    return createField("json", opts);
   }
 };
 export {
@@ -126,9 +197,11 @@ export {
   collectionsSchema,
   dbConfigSchema,
   defineCollection,
+  defineData,
   defineWritableCollection,
   field,
   indexSchema,
   readableCollectionSchema,
+  referenceableFieldSchema,
   writableCollectionSchema
 };

package/dist/core/utils.d.ts

@@ -2,3 +2,4 @@ import type { AstroConfig } from 'astro';
 export type VitePlugin = Required<AstroConfig['vite']>['plugins'][number];
 export declare function getAstroStudioEnv(envMode?: string): Record<`ASTRO_STUDIO_${string}`, string>;
 export declare function getRemoteDatabaseUrl(): string;
+export declare function getAstroStudioUrl(): string;

package/dist/core/utils.js

@@ -5,9 +5,14 @@ function getAstroStudioEnv(envMode = "") {
 }
 function getRemoteDatabaseUrl() {
   const env = getAstroStudioEnv();
-  return env.ASTRO_STUDIO_REMOTE_DB_URL;
+  return env.ASTRO_STUDIO_REMOTE_DB_URL || "https://studio-gateway.fly.dev";
+}
+function getAstroStudioUrl() {
+  const env = getAstroStudioEnv();
+  return env.ASTRO_STUDIO_URL || "https://stardate.astro.build";
 }
 export {
   getAstroStudioEnv,
+  getAstroStudioUrl,
   getRemoteDatabaseUrl
 };

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-export { defineCollection, defineWritableCollection, field } from './core/types.js';
+export { defineCollection, defineWritableCollection, defineData, field } from './core/types.js';
 export type { ResolvedCollectionConfig, DBDataContext } from './core/types.js';
 export { cli } from './core/cli/index.js';
 export { integration as default } from './core/integration/index.js';
+export { sql, NOW, TRUE, FALSE } from './runtime/index.js';

package/dist/index.js

@@ -1,10 +1,16 @@
-import { defineCollection, defineWritableCollection, field } from "./core/types.js";
+import { defineCollection, defineWritableCollection, defineData, field } from "./core/types.js";
 import { cli } from "./core/cli/index.js";
 import { integration } from "./core/integration/index.js";
+import { sql, NOW, TRUE, FALSE } from "./runtime/index.js";
 export {
+  FALSE,
+  NOW,
+  TRUE,
   cli,
   integration as default,
   defineCollection,
+  defineData,
   defineWritableCollection,
-  field
+  field,
+  sql
 };

package/dist/runtime/db-client.js

@@ -40,7 +40,7 @@ function checkIfModificationIsAllowed(collections, Table) {
   }
 }
 function createRemoteDatabaseClient(appToken, remoteDbURL) {
-  const url = new URL("./db/query/", remoteDbURL);
+  const url = new URL("/db/query", remoteDbURL);
   const db = drizzleProxy(async (sql, parameters, method) => {
     const requestBody = { sql, args: parameters };
     console.info(JSON.stringify(requestBody));

package/dist/runtime/index.d.ts

@@ -1,10 +1,14 @@
 import type { SqliteRemoteDatabase } from 'drizzle-orm/sqlite-proxy';
 import { type DBCollection, type DBField } from '../core/types.js';
-import { type ColumnDataType } from 'drizzle-orm';
+import { type ColumnDataType, sql, SQL } from 'drizzle-orm';
+export { sql };
 export type SqliteDB = SqliteRemoteDatabase;
 export type { Table } from './types.js';
 export { createRemoteDatabaseClient, createLocalDatabaseClient } from './db-client.js';
 export declare function hasPrimaryKey(field: DBField): boolean;
+export declare const NOW: SQL<unknown>;
+export declare const TRUE: SQL<unknown>;
+export declare const FALSE: SQL<unknown>;
 export declare function collectionToTable(name: string, collection: DBCollection, isJsonSerializable?: boolean): import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
     name: string;
     schema: undefined;

package/dist/runtime/index.js

@@ -1,5 +1,5 @@
 import {} from "../core/types.js";
-import { sql } from "drizzle-orm";
+import { sql, SQL } from "drizzle-orm";
 import {
   customType,
   integer,
@@ -8,10 +8,14 @@ import {
   index
 } from "drizzle-orm/sqlite-core";
 import { z } from "zod";
+import { isSerializedSQL } from "./types.js";
 import { createRemoteDatabaseClient, createLocalDatabaseClient } from "./db-client.js";
 function hasPrimaryKey(field) {
-  return "primaryKey" in field && !!field.primaryKey;
+  return "primaryKey" in field.schema && !!field.schema.primaryKey;
 }
+const NOW = sql`CURRENT_TIMESTAMP`;
+const TRUE = sql`TRUE`;
+const FALSE = sql`FALSE`;
 const dateType = customType({
   dataType() {
     return "text";
@@ -63,45 +67,46 @@ function columnMapper(fieldName, field, isJsonSerializable) {
   switch (field.type) {
     case "text": {
       c = text(fieldName);
-      if (field.default !== void 0)
-        c = c.default(field.default);
-      if (field.primaryKey === true)
+      if (field.schema.default !== void 0)
+        c = c.default(handleSerializedSQL(field.schema.default));
+      if (field.schema.primaryKey === true)
         c = c.primaryKey();
       break;
     }
     case "number": {
       c = integer(fieldName);
-      if (field.default !== void 0)
-        c = c.default(field.default);
-      if (field.primaryKey === true)
-        c = c.primaryKey({ autoIncrement: true });
+      if (field.schema.default !== void 0)
+        c = c.default(handleSerializedSQL(field.schema.default));
+      if (field.schema.primaryKey === true)
+        c = c.primaryKey();
       break;
     }
     case "boolean": {
       c = integer(fieldName, { mode: "boolean" });
-      if (field.default !== void 0)
-        c = c.default(field.default);
+      if (field.schema.default !== void 0)
+        c = c.default(handleSerializedSQL(field.schema.default));
       break;
     }
     case "json":
       c = jsonType(fieldName);
-      if (field.default !== void 0)
-        c = c.default(field.default);
+      if (field.schema.default !== void 0)
+        c = c.default(field.schema.default);
       break;
     case "date": {
       if (isJsonSerializable) {
         c = text(fieldName);
-        if (field.default !== void 0) {
-          c = c.default(field.default === "now" ? sql`CURRENT_TIMESTAMP` : field.default);
+        if (field.schema.default !== void 0) {
+          c = c.default(handleSerializedSQL(field.schema.default));
         }
       } else {
         c = dateType(fieldName);
-        if (field.default !== void 0) {
+        if (field.schema.default !== void 0) {
+          const def = handleSerializedSQL(field.schema.default);
           c = c.default(
-            field.default === "now" ? sql`CURRENT_TIMESTAMP` : (
+            def instanceof SQL ? def : (
               // default comes pre-transformed to an ISO string for D1 storage.
               // parse back to a Date for Drizzle.
-              z.coerce.date().parse(field.default)
+              z.coerce.date().parse(field.schema.default)
             )
           );
         }
@@ -109,15 +114,25 @@ function columnMapper(fieldName, field, isJsonSerializable) {
       break;
     }
   }
-  if (!field.optional)
+  if (!field.schema.optional)
     c = c.notNull();
-  if (field.unique)
+  if (field.schema.unique)
     c = c.unique();
   return c;
 }
+function handleSerializedSQL(def) {
+  if (isSerializedSQL(def)) {
+    return sql.raw(def.sql);
+  }
+  return def;
+}
 export {
+  FALSE,
+  NOW,
+  TRUE,
   collectionToTable,
   createLocalDatabaseClient,
   createRemoteDatabaseClient,
-  hasPrimaryKey
+  hasPrimaryKey,
+  sql
 };

package/dist/runtime/types.d.ts

@@ -43,7 +43,7 @@ export type AstroJson<T extends GeneratedConfig<'custom'>> = SQLiteColumn<T & {
     baseColumn: never;
 }>;
 export type Column<T extends DBField['type'], S extends GeneratedConfig> = T extends 'boolean' ? AstroBoolean<S> : T extends 'number' ? AstroNumber<S> : T extends 'text' ? AstroText<S> : T extends 'date' ? AstroDate<S> : T extends 'json' ? AstroJson<S> : never;
-export type Table<TTableName extends string, TFields extends Record<string, Pick<DBField, 'type' | 'default' | 'optional'>>> = SQLiteTableWithColumns<{
+export type Table<TTableName extends string, TFields extends Record<string, Pick<DBField, 'type' | 'schema'>>> = SQLiteTableWithColumns<{
     name: TTableName;
     schema: undefined;
     dialect: 'sqlite';
@@ -51,9 +51,19 @@ export type Table<TTableName extends string, TFields extends Record<string, Pick
         [K in Extract<keyof TFields, string>]: Column<TFields[K]['type'], {
             tableName: TTableName;
             name: K;
-            hasDefault: TFields[K]['default'] extends undefined ? false : true;
-            notNull: TFields[K]['optional'] extends true ? false : true;
+            hasDefault: TFields[K] extends {
+                default: NonNullable<unknown>;
+            } ? true : TFields[K] extends {
+                primaryKey: true;
+            } ? true : false;
+            notNull: TFields[K]['schema']['optional'] extends true ? false : true;
         }>;
     };
 }>;
+export declare const SERIALIZED_SQL_KEY = "__serializedSQL";
+export type SerializedSQL = {
+    [SERIALIZED_SQL_KEY]: true;
+    sql: string;
+};
+export declare function isSerializedSQL(value: any): value is SerializedSQL;
 export {};

package/dist/runtime/types.js

@@ -0,0 +1,8 @@
+const SERIALIZED_SQL_KEY = "__serializedSQL";
+function isSerializedSQL(value) {
+  return typeof value === "object" && value !== null && SERIALIZED_SQL_KEY in value;
+}
+export {
+  SERIALIZED_SQL_KEY,
+  isSerializedSQL
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/db",
-  "version": "0.2.2",
+  "version": "0.3.1",
   "description": "",
   "license": "MIT",
   "type": "module",
@@ -52,17 +52,19 @@
     "drizzle-orm": "^0.28.6",
     "kleur": "^4.1.5",
     "nanoid": "^5.0.1",
+    "open": "^10.0.3",
+    "ora": "^7.0.1",
     "prompts": "^2.4.2",
     "yargs-parser": "^21.1.1",
     "zod": "^3.22.4"
   },
   "devDependencies": {
+    "@types/chai": "^4.3.6",
     "@types/deep-diff": "^1.0.5",
     "@types/diff": "^5.0.8",
-    "@types/yargs-parser": "^21.0.3",
-    "@types/chai": "^4.3.6",
     "@types/mocha": "^10.0.2",
     "@types/prompts": "^2.4.8",
+    "@types/yargs-parser": "^21.0.3",
     "chai": "^4.3.10",
     "cheerio": "1.0.0-rc.12",
     "mocha": "^10.2.0",