@astrojs/db 0.7.1 → 0.8.0

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/dist/runtime/index.d.ts

@@ -5,14 +5,7 @@ export { sql };
 export type SqliteDB = LibSQLDatabase;
 export type { Table } from './types.js';
 export { createRemoteDatabaseClient, createLocalDatabaseClient } from './db-client.js';
-export declare function seedLocal({ userSeedGlob, integrationSeedImports, }: {
-    userSeedGlob: Record<string, {
-        default?: () => Promise<void>;
-    }>;
-    integrationSeedImports: Array<() => Promise<{
-        default: () => Promise<void>;
-    }>>;
-}): Promise<void>;
+export { seedLocal } from './seed-local.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>;

package/dist/runtime/index.js

@@ -1,4 +1,3 @@
-import { LibsqlError } from "@libsql/client";
 import { sql } from "drizzle-orm";
 import {
   customType,
@@ -7,40 +6,10 @@ import {
   sqliteTable,
   text
 } from "drizzle-orm/sqlite-core";
-import { SEED_DEFAULT_EXPORT_ERROR, SEED_ERROR } from "../core/errors.js";
 import {} from "../core/types.js";
 import { isSerializedSQL } from "./types.js";
 import { createRemoteDatabaseClient, createLocalDatabaseClient } from "./db-client.js";
-async function seedLocal({
-  // Glob all potential seed files to catch renames and deletions.
-  userSeedGlob,
-  integrationSeedImports
-}) {
-  const seedFilePath = Object.keys(userSeedGlob)[0];
-  if (seedFilePath) {
-    const mod = userSeedGlob[seedFilePath];
-    if (!mod.default) {
-      throw new Error(SEED_DEFAULT_EXPORT_ERROR(seedFilePath));
-    }
-    try {
-      await mod.default();
-    } catch (e) {
-      if (e instanceof LibsqlError) {
-        throw new Error(SEED_ERROR(e.message));
-      }
-      throw e;
-    }
-  }
-  for (const importModule of integrationSeedImports) {
-    const mod = await importModule();
-    await mod.default().catch((e) => {
-      if (e instanceof LibsqlError) {
-        throw new Error(SEED_ERROR(e.message));
-      }
-      throw e;
-    });
-  }
-}
+import { seedLocal } from "./seed-local.js";
 function hasPrimaryKey(column) {
   return "primaryKey" in column.schema && !!column.schema.primaryKey;
 }

package/dist/runtime/seed-local.d.ts

@@ -0,0 +1,10 @@
+import type { LibSQLDatabase } from 'drizzle-orm/libsql';
+import { type DBTables } from '../core/types.js';
+export declare function seedLocal({ db, tables, userSeedGlob, integrationSeedFunctions, }: {
+    db: LibSQLDatabase;
+    tables: DBTables;
+    userSeedGlob: Record<string, {
+        default?: () => Promise<void>;
+    }>;
+    integrationSeedFunctions: Array<() => Promise<void>>;
+}): Promise<void>;

package/dist/runtime/seed-local.js

@@ -0,0 +1,53 @@
+import { LibsqlError } from "@libsql/client";
+import { sql } from "drizzle-orm";
+import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
+import { SEED_DEFAULT_EXPORT_ERROR, SEED_ERROR } from "../core/errors.js";
+import {} from "../core/types.js";
+import { getCreateIndexQueries, getCreateTableQuery } from "./queries.js";
+const sqlite = new SQLiteAsyncDialect();
+async function seedLocal({
+  db,
+  tables,
+  // Glob all potential seed files to catch renames and deletions.
+  userSeedGlob,
+  integrationSeedFunctions
+}) {
+  await recreateTables({ db, tables });
+  const seedFunctions = [];
+  const seedFilePath = Object.keys(userSeedGlob)[0];
+  if (seedFilePath) {
+    const mod = userSeedGlob[seedFilePath];
+    if (!mod.default)
+      throw new Error(SEED_DEFAULT_EXPORT_ERROR(seedFilePath));
+    seedFunctions.push(mod.default);
+  }
+  for (const seedFn of integrationSeedFunctions) {
+    seedFunctions.push(seedFn);
+  }
+  for (const seed of seedFunctions) {
+    try {
+      await seed();
+    } catch (e) {
+      if (e instanceof LibsqlError) {
+        throw new Error(SEED_ERROR(e.message));
+      }
+      throw e;
+    }
+  }
+}
+async function recreateTables({ db, tables }) {
+  const setupQueries = [];
+  for (const [name, table] of Object.entries(tables)) {
+    const dropQuery = sql.raw(`DROP TABLE IF EXISTS ${sqlite.escapeName(name)}`);
+    const createQuery = sql.raw(getCreateTableQuery(name, table));
+    const indexQueries = getCreateIndexQueries(name, table);
+    setupQueries.push(dropQuery, createQuery, ...indexQueries.map((s) => sql.raw(s)));
+  }
+  await db.batch([
+    db.run(sql`pragma defer_foreign_keys=true;`),
+    ...setupQueries.map((q) => db.run(q))
+  ]);
+}
+export {
+  seedLocal
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/db",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "",
   "license": "MIT",
   "type": "module",
@@ -20,10 +20,13 @@
       "types": "./dist/runtime/index.d.ts",
       "import": "./dist/runtime/index.js"
     },
-    "./runtime/config": {
-      "types": "./dist/runtime/config.d.ts",
+    "./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": {
@@ -31,14 +34,14 @@
       ".": [
         "./index.d.ts"
       ],
+      "types": [
+        "./dist/types.d.ts"
+      ],
       "utils": [
         "./dist/utils.d.ts"
       ],
       "runtime": [
         "./dist/runtime/index.d.ts"
-      ],
-      "runtime/config": [
-        "./dist/runtime/config.d.ts"
       ]
     }
   },
@@ -52,7 +55,7 @@
     "astro-integration"
   ],
   "dependencies": {
-    "@libsql/client": "^0.4.3",
+    "@libsql/client": "^0.5.5",
     "async-listen": "^3.0.1",
     "deep-diff": "^1.0.2",
     "drizzle-orm": "^0.29.5",
@@ -77,8 +80,8 @@
     "mocha": "^10.2.0",
     "typescript": "^5.2.2",
     "vite": "^5.1.4",
-    "astro": "4.5.0",
-    "astro-scripts": "0.0.14"
+    "astro-scripts": "0.0.14",
+    "astro": "4.5.2"
   },
   "scripts": {
     "build": "astro-scripts build \"src/**/*.ts\" && tsc",

package/dist/runtime/config.d.ts

@@ -1,148 +0,0 @@
-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;
-        deprecated?: 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;
-                deprecated?: 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;
-                deprecated?: 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;
-        deprecated?: 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;
-        deprecated?: 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;
-                deprecated?: 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;
-                deprecated?: 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;
-        deprecated?: 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;
-        deprecated?: 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 { NOW, TRUE, FALSE } from './index.js';
-export { sql, eq, gt, gte, lt, lte, ne, isNull, isNotNull, inArray, notInArray, exists, notExists, between, notBetween, like, notIlike, not, asc, desc, and, or, } from 'drizzle-orm';