@astrojs/db 0.4.0 → 0.5.0

package/dist/core/types.js

@@ -1,9 +1,8 @@
+import { SQL } from "drizzle-orm";
 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";
+import { errorMap } from "./integration/error-map.js";
 const sqlite = new SQLiteAsyncDialect();
 const sqlSchema = z.instanceof(SQL).transform(
   (sqlObj) => ({
@@ -17,6 +16,7 @@ const baseColumnSchema = z.object({
   unique: 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({
@@ -112,98 +112,30 @@ 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 baseCollectionSchema = z.object({
+const tableSchema = z.object({
   columns: columnsSchema,
   indexes: z.record(indexSchema).optional(),
   foreignKeys: z.array(foreignKeysSchema).optional()
 });
-const readableCollectionSchema = baseCollectionSchema.extend({
-  writable: z.literal(false)
-});
-const writableCollectionSchema = baseCollectionSchema.extend({
-  writable: z.literal(true)
-});
-const collectionSchema = z.union([readableCollectionSchema, writableCollectionSchema]);
-const tablesSchema = z.preprocess((rawCollections) => {
-  const tables = z.record(z.any()).parse(rawCollections, { errorMap });
-  for (const [collectionName, collection] of Object.entries(tables)) {
-    collection.table = collectionToTable(
-      collectionName,
-      collectionSchema.parse(collection, { errorMap })
-    );
-    const { columns } = z.object({ columns: z.record(z.any()) }).parse(collection, { errorMap });
-    for (const [columnName, column2] of Object.entries(columns)) {
-      column2.schema.name = columnName;
-      column2.schema.collection = collectionName;
+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 rawCollections;
-}, z.record(collectionSchema));
-function defineData(fn) {
-  return fn;
-}
-const dbDataFn = z.function().returns(z.union([z.void(), z.promise(z.void())]));
+  return rawTables;
+}, z.record(tableSchema));
 const dbConfigSchema = z.object({
-  studio: z.boolean().optional(),
-  tables: tablesSchema.optional(),
-  data: z.union([dbDataFn, z.array(dbDataFn)]).optional(),
-  unsafeWritable: z.boolean().optional().default(false)
-});
-const astroConfigWithDbSchema = z.object({
-  db: dbConfigSchema.optional()
+  tables: tablesSchema.optional()
 });
-function baseDefineCollection(userConfig, writable) {
-  return {
-    ...userConfig,
-    writable,
-    // set at runtime to get the table name
-    table: null
-  };
-}
-function defineReadableTable(userConfig) {
-  return baseDefineCollection(userConfig, false);
-}
-function defineWritableTable(userConfig) {
-  return baseDefineCollection(userConfig, true);
-}
-function createColumn(type, schema) {
-  return {
-    type,
-    /**
-     * @internal
-     */
-    schema
-  };
-}
-const column = {
-  number: (opts = {}) => {
-    return createColumn("number", opts);
-  },
-  boolean: (opts = {}) => {
-    return createColumn("boolean", opts);
-  },
-  text: (opts = {}) => {
-    return createColumn("text", opts);
-  },
-  date(opts = {}) {
-    return createColumn("date", opts);
-  },
-  json(opts = {}) {
-    return createColumn("json", opts);
-  }
-};
 export {
-  astroConfigWithDbSchema,
-  collectionSchema,
-  column,
   columnSchema,
   dbConfigSchema,
-  defineData,
-  defineReadableTable,
-  defineWritableTable,
   indexSchema,
-  readableCollectionSchema,
   referenceableColumnSchema,
-  tablesSchema,
-  writableCollectionSchema
+  tableSchema,
+  tablesSchema
 };

package/dist/core/utils.d.ts

@@ -3,3 +3,5 @@ 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;
+export declare function getDbDirectoryUrl(root: URL | string): URL;
+export declare function getMigrationsDirectoryUrl(root: URL | string): URL;

package/dist/core/utils.js

@@ -11,8 +11,16 @@ function getAstroStudioUrl() {
   const env = getAstroStudioEnv();
   return env.ASTRO_STUDIO_URL || "https://stardate.astro.build";
 }
+function getDbDirectoryUrl(root) {
+  return new URL("db/", root);
+}
+function getMigrationsDirectoryUrl(root) {
+  return new URL("migrations/", getDbDirectoryUrl(root));
+}
 export {
   getAstroStudioEnv,
   getAstroStudioUrl,
+  getDbDirectoryUrl,
+  getMigrationsDirectoryUrl,
   getRemoteDatabaseUrl
 };

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-export { defineReadableTable, defineWritableTable, defineData, column } from './core/types.js';
-export type { ResolvedCollectionConfig, DBDataContext } from './core/types.js';
+export type { ResolvedCollectionConfig, TableConfig } 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';
+export { sql, NOW, TRUE, FALSE, defineDB, defineTable, column } from './runtime/config.js';

package/dist/index.js

@@ -1,7 +1,6 @@
-import { defineReadableTable, defineWritableTable, defineData, column } 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";
+import { sql, NOW, TRUE, FALSE, defineDB, defineTable, column } from "./runtime/config.js";
 export {
   FALSE,
   NOW,
@@ -9,8 +8,7 @@ export {
   cli,
   column,
   integration as default,
-  defineData,
-  defineReadableTable,
-  defineWritableTable,
+  defineDB,
+  defineTable,
   sql
 };

package/dist/runtime/config.d.ts

@@ -0,0 +1,138 @@
+import type { ColumnsConfig, DBConfigInput, TableConfig } from '../core/types.js';
+export declare const column: {
+    number: <T extends ({
+        name?: string | undefined;
+        label?: string | undefined;
+        unique?: boolean | undefined;
+        collection?: string | undefined;
+    } & ({
+        primaryKey?: false | undefined;
+        optional?: boolean | undefined;
+        default?: number | import("drizzle-orm").SQL<any> | undefined;
+    } | {
+        primaryKey: true;
+        optional?: false | undefined;
+        default?: undefined;
+    })) & {
+        references?: (() => {
+            type: "number";
+            schema: ({
+                name?: string | undefined;
+                label?: string | undefined;
+                unique?: boolean | undefined;
+                collection?: string | undefined;
+            } & {
+                primaryKey?: false | undefined;
+                optional?: boolean | undefined;
+                default?: number | import("drizzle-orm").SQL<any> | undefined;
+            } & any) | ({
+                name?: string | undefined;
+                label?: string | undefined;
+                unique?: boolean | undefined;
+                collection?: string | undefined;
+            } & {
+                primaryKey: true;
+                optional?: false | undefined;
+                default?: undefined;
+            } & any);
+        }) | undefined;
+    }>(opts?: T) => {
+        type: "number";
+        /**
+         * @internal
+         */
+        schema: T;
+    };
+    boolean: <T_1 extends {
+        name?: string | undefined;
+        label?: string | undefined;
+        optional?: boolean | undefined;
+        unique?: boolean | undefined;
+        collection?: string | undefined;
+        default?: boolean | import("drizzle-orm").SQL<any> | undefined;
+    }>(opts?: T_1) => {
+        type: "boolean";
+        /**
+         * @internal
+         */
+        schema: T_1;
+    };
+    text: <T_2 extends ({
+        name?: string | undefined;
+        label?: string | undefined;
+        unique?: boolean | undefined;
+        collection?: string | undefined;
+        default?: string | import("drizzle-orm").SQL<any> | undefined;
+        multiline?: boolean | undefined;
+    } & ({
+        primaryKey?: false | undefined;
+        optional?: boolean | undefined;
+    } | {
+        primaryKey: true;
+        optional?: false | undefined;
+    })) & {
+        references?: (() => {
+            type: "text";
+            schema: ({
+                name?: string | undefined;
+                label?: string | undefined;
+                unique?: boolean | undefined;
+                collection?: string | undefined;
+                default?: string | import("drizzle-orm").SQL<any> | undefined;
+                multiline?: boolean | undefined;
+            } & {
+                primaryKey?: false | undefined;
+                optional?: boolean | undefined;
+            } & any) | ({
+                name?: string | undefined;
+                label?: string | undefined;
+                unique?: boolean | undefined;
+                collection?: string | undefined;
+                default?: string | import("drizzle-orm").SQL<any> | undefined;
+                multiline?: boolean | undefined;
+            } & {
+                primaryKey: true;
+                optional?: false | undefined;
+            } & any);
+        }) | undefined;
+    }>(opts?: T_2) => {
+        type: "text";
+        /**
+         * @internal
+         */
+        schema: T_2;
+    };
+    date<T_3 extends {
+        name?: string | undefined;
+        label?: string | undefined;
+        optional?: boolean | undefined;
+        unique?: boolean | undefined;
+        collection?: string | undefined;
+        default?: Date | import("drizzle-orm").SQL<any> | undefined;
+    }>(opts?: T_3): {
+        type: "date";
+        /**
+         * @internal
+         */
+        schema: T_3;
+    };
+    json<T_4 extends {
+        name?: string | undefined;
+        label?: string | undefined;
+        optional?: boolean | undefined;
+        unique?: boolean | undefined;
+        collection?: string | undefined;
+        default?: unknown;
+    }>(opts?: T_4): {
+        type: "json";
+        /**
+         * @internal
+         */
+        schema: T_4;
+    };
+};
+export declare function defineTable<TColumns extends ColumnsConfig>(userConfig: TableConfig<TColumns>): TableConfig<TColumns>;
+export declare function defineDB(userConfig: DBConfigInput): {
+    tables?: unknown;
+};
+export { sql, NOW, TRUE, FALSE } from './index.js';

package/dist/runtime/config.js

@@ -0,0 +1,42 @@
+function createColumn(type, schema) {
+  return {
+    type,
+    /**
+     * @internal
+     */
+    schema
+  };
+}
+const column = {
+  number: (opts = {}) => {
+    return createColumn("number", opts);
+  },
+  boolean: (opts = {}) => {
+    return createColumn("boolean", opts);
+  },
+  text: (opts = {}) => {
+    return createColumn("text", opts);
+  },
+  date(opts = {}) {
+    return createColumn("date", opts);
+  },
+  json(opts = {}) {
+    return createColumn("json", opts);
+  }
+};
+function defineTable(userConfig) {
+  return userConfig;
+}
+function defineDB(userConfig) {
+  return userConfig;
+}
+import { sql, NOW, TRUE, FALSE } from "./index.js";
+export {
+  FALSE,
+  NOW,
+  TRUE,
+  column,
+  defineDB,
+  defineTable,
+  sql
+};

package/dist/runtime/db-client.d.ts

@@ -1,12 +1,5 @@
-/// <reference types="node" resolution-mode="require"/>
-import { type DBTables } from '../core/types.js';
 import type { LibSQLDatabase } from 'drizzle-orm/libsql';
-interface LocalDatabaseClient extends LibSQLDatabase, Disposable {
-}
-export declare function createLocalDatabaseClient({ tables, dbUrl, seeding, }: {
+export declare function createLocalDatabaseClient({ dbUrl }: {
     dbUrl: string;
-    tables: DBTables;
-    seeding: boolean;
-}): Promise<LocalDatabaseClient>;
+}): LibSQLDatabase;
 export declare function createRemoteDatabaseClient(appToken: string, remoteDbURL: string): import("drizzle-orm/sqlite-proxy").SqliteRemoteDatabase<Record<string, never>>;
-export {};

package/dist/runtime/db-client.js

@@ -1,53 +1,19 @@
 import { createClient } from "@libsql/client";
-import {} from "../core/types.js";
 import { drizzle as drizzleLibsql } from "drizzle-orm/libsql";
 import { drizzle as drizzleProxy } from "drizzle-orm/sqlite-proxy";
-import {} from "drizzle-orm/sqlite-core";
 import { z } from "zod";
-import { getTableName } from "drizzle-orm";
 const isWebContainer = !!process.versions?.webcontainer;
-async function createLocalDatabaseClient({
-  tables,
-  dbUrl,
-  seeding
-}) {
+function createLocalDatabaseClient({ dbUrl }) {
   const url = isWebContainer ? "file:content.db" : dbUrl;
-  const client = createClient({ url });
-  const db = Object.assign(drizzleLibsql(client), {
-    [Symbol.dispose || Symbol.for("Symbol.dispose")]() {
-      client.close();
-    }
-  });
-  if (seeding)
-    return db;
-  const { insert: drizzleInsert, update: drizzleUpdate, delete: drizzleDelete } = db;
-  return Object.assign(db, {
-    insert(Table) {
-      checkIfModificationIsAllowed(tables, Table);
-      return drizzleInsert.call(this, Table);
-    },
-    update(Table) {
-      checkIfModificationIsAllowed(tables, Table);
-      return drizzleUpdate.call(this, Table);
-    },
-    delete(Table) {
-      checkIfModificationIsAllowed(tables, Table);
-      return drizzleDelete.call(this, Table);
-    }
-  });
-}
-function checkIfModificationIsAllowed(tables, Table) {
-  const tableName = getTableName(Table);
-  const collection = tables[tableName];
-  if (!collection.writable) {
-    throw new Error(`The [${tableName}] collection is read-only.`);
-  }
+  console.log("memory", process.env.TEST_IN_MEMORY_DB);
+  const client = createClient({ url: process.env.TEST_IN_MEMORY_DB ? ":memory:" : url });
+  const db = drizzleLibsql(client);
+  return db;
 }
 function createRemoteDatabaseClient(appToken, 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));
     const res = await fetch(url, {
       method: "POST",
       headers: {
@@ -88,6 +54,9 @@ Full error: Unexpected JSON response. ${e instanceof Error ? e.message : String(
     }
     return { rows: rowValues };
   });
+  db.batch = (_drizzleQueries) => {
+    throw new Error("db.batch() is not currently supported.");
+  };
   return db;
 }
 export {

package/dist/runtime/index.d.ts

@@ -1,15 +1,16 @@
-import type { SqliteRemoteDatabase } from 'drizzle-orm/sqlite-proxy';
-import { type DBTable, type DBColumn } from '../core/types.js';
 import { type ColumnDataType, sql } from 'drizzle-orm';
+import type { LibSQLDatabase } from 'drizzle-orm/libsql';
+import { type DBColumn, type DBTable } from '../core/types.js';
 export { sql };
-export type SqliteDB = SqliteRemoteDatabase;
+export type SqliteDB = LibSQLDatabase;
 export type { Table } from './types.js';
 export { createRemoteDatabaseClient, createLocalDatabaseClient } from './db-client.js';
+export { seedLocal } from './queries.js';
 export declare function hasPrimaryKey(column: DBColumn): boolean;
 export declare const NOW: import("drizzle-orm").SQL<unknown>;
 export declare const TRUE: import("drizzle-orm").SQL<unknown>;
 export declare const FALSE: import("drizzle-orm").SQL<unknown>;
-export declare function collectionToTable(name: string, collection: DBTable): import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+export declare function asDrizzleTable(name: string, table: DBTable): import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
     name: string;
     schema: undefined;
     columns: {

package/dist/runtime/index.js

@@ -1,14 +1,15 @@
-import {} from "../core/types.js";
 import { sql } from "drizzle-orm";
 import {
   customType,
+  index,
   integer,
   sqliteTable,
-  text,
-  index
+  text
 } from "drizzle-orm/sqlite-core";
+import {} from "../core/types.js";
 import { isSerializedSQL } from "./types.js";
 import { createRemoteDatabaseClient, createLocalDatabaseClient } from "./db-client.js";
+import { seedLocal } from "./queries.js";
 function hasPrimaryKey(column) {
   return "primaryKey" in column.schema && !!column.schema.primaryKey;
 }
@@ -37,17 +38,17 @@ const jsonType = customType({
     return JSON.parse(value);
   }
 });
-function collectionToTable(name, collection) {
+function asDrizzleTable(name, table) {
   const columns = {};
-  if (!Object.entries(collection.columns).some(([, column]) => hasPrimaryKey(column))) {
+  if (!Object.entries(table.columns).some(([, column]) => hasPrimaryKey(column))) {
     columns["_id"] = integer("_id").primaryKey();
   }
-  for (const [columnName, column] of Object.entries(collection.columns)) {
+  for (const [columnName, column] of Object.entries(table.columns)) {
     columns[columnName] = columnMapper(columnName, column);
   }
-  const table = sqliteTable(name, columns, (ormTable) => {
+  const drizzleTable = sqliteTable(name, columns, (ormTable) => {
     const indexes = {};
-    for (const [indexName, indexProps] of Object.entries(collection.indexes ?? {})) {
+    for (const [indexName, indexProps] of Object.entries(table.indexes ?? {})) {
       const onColNames = Array.isArray(indexProps.on) ? indexProps.on : [indexProps.on];
       const onCols = onColNames.map((colName) => ormTable[colName]);
       if (!atLeastOne(onCols))
@@ -56,7 +57,7 @@ function collectionToTable(name, collection) {
     }
     return indexes;
   });
-  return table;
+  return drizzleTable;
 }
 function atLeastOne(arr) {
   return arr.length > 0;
@@ -116,9 +117,10 @@ export {
   FALSE,
   NOW,
   TRUE,
-  collectionToTable,
+  asDrizzleTable,
   createLocalDatabaseClient,
   createRemoteDatabaseClient,
   hasPrimaryKey,
+  seedLocal,
   sql
 };

package/dist/{core → runtime}/queries.d.ts

@@ -1,20 +1,18 @@
-import type { SqliteRemoteDatabase } from 'drizzle-orm/sqlite-proxy';
-import { type BooleanColumn, type DBTable, type DBTables, type DBColumn, type DateColumn, type ColumnType, type JsonColumn, type NumberColumn, type TextColumn } from '../core/types.js';
-import type { AstroIntegrationLogger } from 'astro';
-import type { DBUserConfig } from '../core/types.js';
-export declare function recreateTables({ db, tables, }: {
-    db: SqliteRemoteDatabase;
+import type { BooleanColumn, ColumnType, DBColumn, DBTable, DBTables, DateColumn, JsonColumn, NumberColumn, TextColumn } from '../core/types.js';
+import { type SqliteDB } from './index.js';
+export declare const SEED_DEV_FILE_NAME: string[];
+export declare function seedLocal({ db, tables, fileGlob, }: {
+    db: SqliteDB;
     tables: DBTables;
+    fileGlob: Record<string, () => Promise<void>>;
 }): Promise<void>;
-export declare function seedData({ db, data, logger, mode, }: {
-    db: SqliteRemoteDatabase;
-    data: DBUserConfig['data'];
-    logger?: AstroIntegrationLogger;
-    mode: 'dev' | 'build';
+export declare function recreateTables({ db, tables }: {
+    db: SqliteDB;
+    tables: DBTables;
 }): Promise<void>;
-export declare function getCreateTableQuery(collectionName: string, collection: DBTable): string;
-export declare function getCreateIndexQueries(collectionName: string, collection: Pick<DBTable, 'indexes'>): string[];
-export declare function getCreateForeignKeyQueries(collectionName: string, collection: DBTable): string[];
+export declare function getCreateTableQuery(tableName: string, table: DBTable): string;
+export declare function getCreateIndexQueries(tableName: string, table: Pick<DBTable, 'indexes'>): string[];
+export declare function getCreateForeignKeyQueries(tableName: string, table: DBTable): string[];
 export declare function schemaTypeToSqlType(type: ColumnType): 'text' | 'integer';
 export declare function getModifiers(columnName: string, column: DBColumn): string;
 export declare function getReferencesConfig(column: DBColumn): {
@@ -27,7 +25,7 @@ export declare function getReferencesConfig(column: DBColumn): {
     } & {
         optional: boolean;
         primaryKey: false;
-        default?: number | import("../runtime/types.js").SerializedSQL | undefined;
+        default?: number | import("./types.js").SerializedSQL | undefined;
     } & {
         references?: any | undefined;
     }) | ({
@@ -49,7 +47,7 @@ export declare function getReferencesConfig(column: DBColumn): {
         name?: string | undefined;
         label?: string | undefined;
         collection?: string | undefined;
-        default?: string | import("../runtime/types.js").SerializedSQL | undefined;
+        default?: string | import("./types.js").SerializedSQL | undefined;
         multiline?: boolean | undefined;
     } & {
         optional: boolean;
@@ -61,7 +59,7 @@ export declare function getReferencesConfig(column: DBColumn): {
         name?: string | undefined;
         label?: string | undefined;
         collection?: string | undefined;
-        default?: string | import("../runtime/types.js").SerializedSQL | undefined;
+        default?: string | import("./types.js").SerializedSQL | undefined;
         multiline?: boolean | undefined;
     } & {
         primaryKey: true;