@astrojs/db 0.1.0

package/dist/config.js

@@ -0,0 +1,53 @@
+import {
+  collectionsSchema
+} from "./types.js";
+import { z } from "zod";
+const dbConfigSchema = z.object({
+  studio: z.boolean().optional(),
+  collections: collectionsSchema.optional()
+});
+const astroConfigWithDbSchema = z.object({
+  db: dbConfigSchema.optional()
+});
+function defineCollection(userConfig) {
+  return {
+    ...userConfig,
+    writable: false
+  };
+}
+function defineWritableCollection(userConfig) {
+  return {
+    ...userConfig,
+    writable: true
+  };
+}
+const baseDefaults = {
+  optional: false,
+  unique: false,
+  label: void 0,
+  default: void 0
+};
+const field = {
+  number(opts = {}) {
+    return { type: "number", ...baseDefaults, ...opts };
+  },
+  boolean(opts = {}) {
+    return { type: "boolean", ...baseDefaults, ...opts };
+  },
+  text(opts = {}) {
+    return { type: "text", multiline: false, ...baseDefaults, ...opts };
+  },
+  date(opts = {}) {
+    return { type: "date", ...baseDefaults, ...opts };
+  },
+  json(opts = {}) {
+    return { type: "json", ...baseDefaults, ...opts };
+  }
+};
+export {
+  astroConfigWithDbSchema,
+  dbConfigSchema,
+  defineCollection,
+  defineWritableCollection,
+  field
+};

package/dist/consts.d.ts

@@ -0,0 +1,6 @@
+export declare const PACKAGE_NAME: any;
+export declare const INTERNAL_MOD_IMPORT: string;
+export declare const DRIZZLE_MOD_IMPORT: string;
+export declare const DB_TYPES_FILE = "db-types.d.ts";
+export declare const VIRTUAL_MODULE_ID = "astro:db";
+export declare function getLocalDbUrl(root: URL): URL;

package/dist/consts.js

@@ -0,0 +1,19 @@
+import { readFileSync } from "node:fs";
+const PACKAGE_NAME = JSON.parse(
+  readFileSync(new URL("../package.json", import.meta.url), "utf8")
+).name;
+const INTERNAL_MOD_IMPORT = JSON.stringify(`${PACKAGE_NAME}/internal`);
+const DRIZZLE_MOD_IMPORT = JSON.stringify(`${PACKAGE_NAME}/internal-drizzle`);
+const DB_TYPES_FILE = "db-types.d.ts";
+const VIRTUAL_MODULE_ID = "astro:db";
+function getLocalDbUrl(root) {
+  return new URL(".astro/content.db", root);
+}
+export {
+  DB_TYPES_FILE,
+  DRIZZLE_MOD_IMPORT,
+  INTERNAL_MOD_IMPORT,
+  PACKAGE_NAME,
+  VIRTUAL_MODULE_ID,
+  getLocalDbUrl
+};

package/dist/error-map.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This is a modified version of Astro's error map. source:
+ * https://github.com/withastro/astro/blob/main/packages/astro/src/content/error-map.ts
+ */
+import type { z } from 'astro/zod';
+export declare const errorMap: z.ZodErrorMap;

package/dist/error-map.js

@@ -0,0 +1,79 @@
+const errorMap = (baseError, ctx) => {
+  const baseErrorPath = flattenErrorPath(baseError.path);
+  if (baseError.code === "invalid_union") {
+    const typeOrLiteralErrByPath = /* @__PURE__ */ new Map();
+    for (const unionError of baseError.unionErrors.flatMap((e) => e.errors)) {
+      if (unionError.code === "invalid_type" || unionError.code === "invalid_literal") {
+        const flattenedErrorPath = flattenErrorPath(unionError.path);
+        const typeOrLiteralErr = typeOrLiteralErrByPath.get(flattenedErrorPath);
+        if (typeOrLiteralErr) {
+          typeOrLiteralErr.expected.push(unionError.expected);
+        } else {
+          typeOrLiteralErrByPath.set(flattenedErrorPath, {
+            code: unionError.code,
+            received: unionError.received,
+            expected: [unionError.expected]
+          });
+        }
+      }
+    }
+    const messages = [
+      prefix(
+        baseErrorPath,
+        typeOrLiteralErrByPath.size ? "Did not match union:" : "Did not match union."
+      )
+    ];
+    return {
+      message: messages.concat(
+        [...typeOrLiteralErrByPath.entries()].filter(([, error]) => error.expected.length === baseError.unionErrors.length).map(
+          ([key, error]) => (
+            // Avoid printing the key again if it's a base error
+            key === baseErrorPath ? `> ${getTypeOrLiteralMsg(error)}` : `> ${prefix(key, getTypeOrLiteralMsg(error))}`
+          )
+        )
+      ).join("\n")
+    };
+  }
+  if (baseError.code === "invalid_literal" || baseError.code === "invalid_type") {
+    return {
+      message: prefix(
+        baseErrorPath,
+        getTypeOrLiteralMsg({
+          code: baseError.code,
+          received: baseError.received,
+          expected: [baseError.expected]
+        })
+      )
+    };
+  } else if (baseError.message) {
+    return { message: prefix(baseErrorPath, baseError.message) };
+  } else {
+    return { message: prefix(baseErrorPath, ctx.defaultError) };
+  }
+};
+const getTypeOrLiteralMsg = (error) => {
+  if (error.received === "undefined")
+    return "Required";
+  const expectedDeduped = new Set(error.expected);
+  switch (error.code) {
+    case "invalid_type":
+      return `Expected type \`${unionExpectedVals(expectedDeduped)}\`, received ${JSON.stringify(
+        error.received
+      )}`;
+    case "invalid_literal":
+      return `Expected \`${unionExpectedVals(expectedDeduped)}\`, received ${JSON.stringify(
+        error.received
+      )}`;
+  }
+};
+const prefix = (key, msg) => key.length ? `**${key}**: ${msg}` : msg;
+const unionExpectedVals = (expectedVals) => [...expectedVals].map((expectedVal, idx) => {
+  if (idx === 0)
+    return JSON.stringify(expectedVal);
+  const sep = " | ";
+  return `${sep}${JSON.stringify(expectedVal)}`;
+}).join("");
+const flattenErrorPath = (errorPath) => errorPath.join(".");
+export {
+  errorMap
+};

package/dist/errors.d.ts

@@ -0,0 +1,3 @@
+export declare const unexpectedAstroAdminError: string;
+export declare const authenticationError: string;
+export declare const appTokenError: string;

package/dist/errors.js

@@ -0,0 +1,15 @@
+import { red } from "kleur/colors";
+const unexpectedAstroAdminError = `${red(
+  "Unexpected response from Astro Studio servers."
+)} Try updating your package version. If the problem persists, please contact support.`;
+const authenticationError = `${red(
+  "\u26A0\uFE0F Login session invalid or expired."
+)} Please run \`astro login\` again.`;
+const appTokenError = `${red(
+  "\u26A0\uFE0F App token invalid or expired."
+)} Please generate a new one from your the Studio dashboard under project settings.`;
+export {
+  appTokenError,
+  authenticationError,
+  unexpectedAstroAdminError
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { defineCollection, defineWritableCollection, field } from './config.js';
+export { cli } from './cli/index.js';
+export { integration as default } from './integration.js';

package/dist/index.js

@@ -0,0 +1,10 @@
+import { defineCollection, defineWritableCollection, field } from "./config.js";
+import { cli } from "./cli/index.js";
+import { integration } from "./integration.js";
+export {
+  cli,
+  integration as default,
+  defineCollection,
+  defineWritableCollection,
+  field
+};

package/dist/integration.d.ts

@@ -0,0 +1,2 @@
+import type { AstroIntegration } from 'astro';
+export declare function integration(): AstroIntegration;

package/dist/integration.js

@@ -0,0 +1,68 @@
+import { vitePluginDb } from "./vite-plugin-db.js";
+import { vitePluginInjectEnvTs } from "./vite-plugin-inject-env-ts.js";
+import { typegen } from "./typegen.js";
+import { existsSync } from "fs";
+import { mkdir, rm, writeFile } from "fs/promises";
+import { getLocalDbUrl } from "./consts.js";
+import { createLocalDatabaseClient, setupDbTables } from "./internal.js";
+import { astroConfigWithDbSchema } from "./config.js";
+import { getAstroStudioEnv } from "./utils.js";
+import { appTokenError } from "./errors.js";
+import { errorMap } from "./error-map.js";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import { bold } from "kleur/colors";
+function integration() {
+  return {
+    name: "astro:db",
+    hooks: {
+      async "astro:config:setup"({ logger, updateConfig, config, command }) {
+        if (command === "preview")
+          return;
+        const configWithDb = astroConfigWithDbSchema.parse(config, { errorMap });
+        const collections = configWithDb.db?.collections ?? {};
+        const studio = configWithDb.db?.studio ?? false;
+        if (!studio && Object.values(collections).some((c) => c.writable)) {
+          logger.warn(
+            `Writable collections should only be used with Astro Studio. Did you set the ${bold(
+              "studio"
+            )} flag in your astro config?`
+          );
+        }
+        let dbPlugin;
+        if (studio && command === "build") {
+          const appToken = getAstroStudioEnv().ASTRO_STUDIO_APP_TOKEN;
+          if (!appToken) {
+            logger.error(appTokenError);
+            process.exit(0);
+          }
+          dbPlugin = vitePluginDb({ connectToStudio: true, collections, appToken });
+        } else {
+          const dbUrl = getLocalDbUrl(config.root);
+          if (existsSync(dbUrl)) {
+            await rm(dbUrl);
+          }
+          await mkdir(dirname(fileURLToPath(dbUrl)), { recursive: true });
+          await writeFile(dbUrl, "");
+          const db = await createLocalDatabaseClient({
+            collections,
+            dbUrl: dbUrl.href,
+            seeding: true
+          });
+          await setupDbTables({ db, collections, logger });
+          logger.info("Collections set up \u{1F680}");
+          dbPlugin = vitePluginDb({ connectToStudio: false, collections, dbUrl: dbUrl.href });
+        }
+        updateConfig({
+          vite: {
+            plugins: [dbPlugin, vitePluginInjectEnvTs(config)]
+          }
+        });
+        await typegen({ collections, root: config.root });
+      }
+    }
+  };
+}
+export {
+  integration
+};

package/dist/internal-drizzle.d.ts

@@ -0,0 +1 @@
+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';

package/dist/internal-drizzle.js

@@ -0,0 +1,48 @@
+import {
+  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";
+export {
+  and,
+  asc,
+  between,
+  desc,
+  eq,
+  exists,
+  gt,
+  gte,
+  inArray,
+  isNotNull,
+  isNull,
+  like,
+  lt,
+  lte,
+  ne,
+  not,
+  notBetween,
+  notExists,
+  notIlike,
+  notInArray,
+  or,
+  sql
+};

package/dist/internal.d.ts

@@ -0,0 +1,50 @@
+import type { SqliteRemoteDatabase } from 'drizzle-orm/sqlite-proxy';
+import { type DBCollection, type DBCollections } from './types.js';
+import { type LibSQLDatabase } from 'drizzle-orm/libsql';
+import { type ColumnDataType } from 'drizzle-orm';
+import type { AstroIntegrationLogger } from 'astro';
+export type SqliteDB = SqliteRemoteDatabase;
+export type { AstroTable, AstroText, AstroDate, AstroBoolean, AstroNumber, AstroJson, AstroId, } from './types.js';
+export { createRemoteDatabaseClient } from './utils.js';
+export declare function createLocalDatabaseClient({ collections, dbUrl, seeding, }: {
+    dbUrl: string;
+    collections: DBCollections;
+    seeding: boolean;
+}): Promise<LibSQLDatabase<Record<string, never>>>;
+export declare function setupDbTables({ db, collections, logger, }: {
+    db: LibSQLDatabase;
+    collections: DBCollections;
+    logger: AstroIntegrationLogger;
+}): Promise<void>;
+export declare function getCreateTableQuery(collectionName: string, collection: DBCollection): string;
+export declare function collectionToTable(name: string, collection: DBCollection, isJsonSerializable?: boolean): import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: string;
+    schema: undefined;
+    columns: {
+        [x: string]: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: string;
+            dataType: ColumnDataType;
+            columnType: string;
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            enumValues: string[] | undefined;
+            baseColumn: never;
+        }, object>;
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, object>;
+    };
+    dialect: "sqlite";
+}>;

package/dist/internal.js

@@ -0,0 +1,250 @@
+import { createClient } from "@libsql/client";
+import {
+} from "./types.js";
+import { drizzle } from "drizzle-orm/libsql";
+import { bold } from "kleur/colors";
+import {
+  sql,
+  getTableName
+} from "drizzle-orm";
+import {
+  SQLiteAsyncDialect,
+  customType,
+  integer,
+  sqliteTable,
+  text
+} from "drizzle-orm/sqlite-core";
+import { z } from "zod";
+import { nanoid } from "nanoid";
+const sqlite = new SQLiteAsyncDialect();
+function isReadableCollection(collection) {
+  return !collection.writable;
+}
+function checkIfModificationIsAllowed(collections, Table) {
+  const tableName = getTableName(Table);
+  const collection = collections[tableName];
+  if (!collection.writable) {
+    throw new Error(`The [${tableName}] collection is read-only.`);
+  }
+}
+import { createRemoteDatabaseClient } from "./utils.js";
+async function createLocalDatabaseClient({
+  collections,
+  dbUrl,
+  seeding
+}) {
+  const client = createClient({ url: dbUrl });
+  const db = drizzle(client);
+  if (seeding)
+    return db;
+  const { insert: drizzleInsert, update: drizzleUpdate, delete: drizzleDelete } = db;
+  return Object.assign(db, {
+    insert(Table) {
+      checkIfModificationIsAllowed(collections, Table);
+      return drizzleInsert.call(this, Table);
+    },
+    update(Table) {
+      checkIfModificationIsAllowed(collections, Table);
+      return drizzleUpdate.call(this, Table);
+    },
+    delete(Table) {
+      checkIfModificationIsAllowed(collections, Table);
+      return drizzleDelete.call(this, Table);
+    }
+  });
+}
+async function setupDbTables({
+  db,
+  collections,
+  logger
+}) {
+  const setupQueries = [];
+  for (const [name, collection] of Object.entries(collections)) {
+    const dropQuery = sql.raw(`DROP TABLE IF EXISTS ${name}`);
+    const createQuery = sql.raw(getCreateTableQuery(name, collection));
+    setupQueries.push(dropQuery, createQuery);
+  }
+  for (const q of setupQueries) {
+    await db.run(q);
+  }
+  for (const [name, collection] of Object.entries(collections)) {
+    if (!isReadableCollection(collection) || !collection.data)
+      continue;
+    const table = collectionToTable(name, collection);
+    try {
+      await db.insert(table).values(await collection.data());
+    } catch (e) {
+      logger.error(
+        `Failed to seed ${bold(
+          name
+        )} data. Did you update to match recent schema changes? Full error:
+
+${e}`
+      );
+    }
+  }
+}
+function getCreateTableQuery(collectionName, collection) {
+  let query = `CREATE TABLE ${sqlite.escapeName(collectionName)} (`;
+  const colQueries = ['"id" text PRIMARY KEY'];
+  for (const [columnName, column] of Object.entries(collection.fields)) {
+    const colQuery = `${sqlite.escapeName(columnName)} ${schemaTypeToSqlType(
+      column.type
+    )}${getModifiers(columnName, column)}`;
+    colQueries.push(colQuery);
+  }
+  query += colQueries.join(", ") + ")";
+  return query;
+}
+function schemaTypeToSqlType(type) {
+  switch (type) {
+    case "date":
+    case "text":
+    case "json":
+      return "text";
+    case "number":
+    case "boolean":
+      return "integer";
+  }
+}
+function getModifiers(columnName, column) {
+  let modifiers = "";
+  if (!column.optional) {
+    modifiers += " NOT NULL";
+  }
+  if (column.unique) {
+    modifiers += " UNIQUE";
+  }
+  if (hasDefault(column)) {
+    modifiers += ` DEFAULT ${getDefaultValueSql(columnName, column)}`;
+  }
+  return modifiers;
+}
+function hasDefault(field) {
+  return field.default !== void 0;
+}
+function getDefaultValueSql(columnName, column) {
+  switch (column.type) {
+    case "boolean":
+      return column.default ? "TRUE" : "FALSE";
+    case "number":
+      return `${column.default}`;
+    case "text":
+      return sqlite.escapeString(column.default);
+    case "date":
+      return column.default === "now" ? "CURRENT_TIMESTAMP" : sqlite.escapeString(column.default);
+    case "json": {
+      let stringified = "";
+      try {
+        stringified = JSON.stringify(column.default);
+      } catch (e) {
+        console.info(
+          `Invalid default value for column ${bold(
+            columnName
+          )}. Defaults must be valid JSON when using the \`json()\` type.`
+        );
+        process.exit(0);
+      }
+      return sqlite.escapeString(stringified);
+    }
+  }
+}
+function generateId() {
+  return nanoid(12);
+}
+const dateType = customType({
+  dataType() {
+    return "text";
+  },
+  toDriver(value) {
+    return value.toISOString();
+  },
+  fromDriver(value) {
+    return new Date(value);
+  }
+});
+const jsonType = customType({
+  dataType() {
+    return "text";
+  },
+  toDriver(value) {
+    return JSON.stringify(value);
+  },
+  fromDriver(value) {
+    return JSON.parse(value);
+  }
+});
+const initialColumns = {
+  id: text("id").primaryKey().$default(() => generateId())
+};
+function collectionToTable(name, collection, isJsonSerializable = true) {
+  const columns = {
+    // Spread to avoid mutating `initialColumns`
+    ...initialColumns
+  };
+  for (const [fieldName, field] of Object.entries(collection.fields)) {
+    columns[fieldName] = columnMapper(fieldName, field, isJsonSerializable);
+  }
+  const table = sqliteTable(name, columns);
+  return table;
+}
+function columnMapper(fieldName, field, isJsonSerializable) {
+  let c;
+  switch (field.type) {
+    case "text": {
+      c = text(fieldName);
+      if (field.default !== void 0)
+        c = c.default(field.default);
+      break;
+    }
+    case "number": {
+      c = integer(fieldName);
+      if (field.default !== void 0)
+        c = c.default(field.default);
+      break;
+    }
+    case "boolean": {
+      c = integer(fieldName, { mode: "boolean" });
+      if (field.default !== void 0)
+        c = c.default(field.default);
+      break;
+    }
+    case "json":
+      c = jsonType(fieldName);
+      if (field.default !== void 0)
+        c = c.default(field.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);
+        }
+      } else {
+        c = dateType(fieldName);
+        if (field.default !== void 0) {
+          c = c.default(
+            field.default === "now" ? sql`CURRENT_TIMESTAMP` : (
+              // default comes pre-transformed to an ISO string for D1 storage.
+              // parse back to a Date for Drizzle.
+              z.coerce.date().parse(field.default)
+            )
+          );
+        }
+      }
+      break;
+    }
+  }
+  if (!field.optional)
+    c = c.notNull();
+  if (field.unique)
+    c = c.unique();
+  return c;
+}
+export {
+  collectionToTable,
+  createLocalDatabaseClient,
+  createRemoteDatabaseClient,
+  getCreateTableQuery,
+  setupDbTables
+};

package/dist/load-astro-config.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Pulled from the mothership, Astro core ❤️
+ *
+ * @see https://github.com/withastro/astro/blob/main/packages/astro/src/core/config/config.ts#L121
+ */
+export declare function loadAstroConfig(root: string): Promise<Record<string, unknown>>;