@astrojs/db 0.0.0-10646-20240402132948

package/dist/runtime/db-client.js

@@ -0,0 +1,148 @@
+import { createClient } from "@libsql/client";
+import { drizzle as drizzleLibsql } from "drizzle-orm/libsql";
+import { drizzle as drizzleProxy } from "drizzle-orm/sqlite-proxy";
+import { z } from "zod";
+import { AstroDbError, safeFetch } from "./utils.js";
+const isWebContainer = !!process.versions?.webcontainer;
+function applyTransactionNotSupported(db) {
+  Object.assign(db, {
+    transaction() {
+      throw new Error(
+        "`db.transaction()` is not currently supported. We recommend `db.batch()` for automatic error rollbacks across multiple queries."
+      );
+    }
+  });
+}
+function createLocalDatabaseClient({ dbUrl }) {
+  const url = isWebContainer ? "file:content.db" : dbUrl;
+  const client = createClient({ url });
+  const db = drizzleLibsql(client);
+  applyTransactionNotSupported(db);
+  return db;
+}
+const remoteResultSchema = z.object({
+  columns: z.array(z.string()),
+  columnTypes: z.array(z.string()),
+  rows: z.array(z.array(z.unknown())),
+  rowsAffected: z.number(),
+  lastInsertRowid: z.unknown().optional()
+});
+function createRemoteDatabaseClient(appToken, remoteDbURL) {
+  if (appToken == null) {
+    throw new Error(`Cannot create a remote client: missing app token.`);
+  }
+  const url = new URL("/db/query", remoteDbURL);
+  const db = drizzleProxy(
+    async (sql, parameters, method) => {
+      const requestBody = { sql, args: parameters };
+      const res = await safeFetch(
+        url,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${appToken}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(requestBody)
+        },
+        async (response) => {
+          throw await parseRemoteError(response);
+        }
+      );
+      let remoteResult;
+      try {
+        const json = await res.json();
+        remoteResult = remoteResultSchema.parse(json);
+      } catch (e) {
+        throw new AstroDbError(await getUnexpectedResponseMessage(res));
+      }
+      if (method === "run")
+        return remoteResult;
+      const rowValues = [];
+      for (const row of remoteResult.rows) {
+        if (row != null && typeof row === "object") {
+          rowValues.push(Object.values(row));
+        }
+      }
+      if (method === "get") {
+        return { rows: rowValues[0] };
+      }
+      return { rows: rowValues };
+    },
+    async (queries) => {
+      const stmts = queries.map(({ sql, params }) => ({ sql, args: params }));
+      const res = await safeFetch(
+        url,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${appToken}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(stmts)
+        },
+        async (response) => {
+          throw await parseRemoteError(response);
+        }
+      );
+      let remoteResults;
+      try {
+        const json = await res.json();
+        remoteResults = z.array(remoteResultSchema).parse(json);
+      } catch (e) {
+        throw new AstroDbError(await getUnexpectedResponseMessage(res));
+      }
+      let results = [];
+      for (const [idx, rawResult] of remoteResults.entries()) {
+        if (queries[idx]?.method === "run") {
+          results.push(rawResult);
+          continue;
+        }
+        const rowValues = [];
+        for (const row of rawResult.rows) {
+          if (row != null && typeof row === "object") {
+            rowValues.push(Object.values(row));
+          }
+        }
+        if (queries[idx]?.method === "get") {
+          results.push({ rows: rowValues[0] });
+        }
+        results.push({ rows: rowValues });
+      }
+      return results;
+    }
+  );
+  applyTransactionNotSupported(db);
+  return db;
+}
+const errorSchema = z.object({
+  success: z.boolean(),
+  error: z.object({
+    code: z.string(),
+    details: z.string().optional()
+  })
+});
+const KNOWN_ERROR_CODES = {
+  SQL_QUERY_FAILED: "SQL_QUERY_FAILED"
+};
+const getUnexpectedResponseMessage = async (response) => `Unexpected response from remote database:
+(Status ${response.status}) ${await response.text()}`;
+async function parseRemoteError(response) {
+  let error;
+  try {
+    error = errorSchema.parse(await response.json()).error;
+  } catch (e) {
+    return new AstroDbError(await getUnexpectedResponseMessage(response));
+  }
+  let details = error.details?.replace(/.*SQLite error: /, "") ?? `(Code ${error.code}) 
+Error querying remote database.`;
+  let hint = `See the Astro DB guide for query and push instructions: https://docs.astro.build/en/guides/astro-db/#query-your-database`;
+  if (error.code === KNOWN_ERROR_CODES.SQL_QUERY_FAILED && details.includes("no such table")) {
+    hint = `Did you run \`astro db push\` to push your latest table schemas?`;
+  }
+  return new AstroDbError(details, hint);
+}
+export {
+  createLocalDatabaseClient,
+  createRemoteDatabaseClient
+};

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

@@ -0,0 +1,5 @@
+export declare const FOREIGN_KEY_DNE_ERROR: (tableName: string) => string;
+export declare const FOREIGN_KEY_REFERENCES_LENGTH_ERROR: (tableName: string) => string;
+export declare const FOREIGN_KEY_REFERENCES_EMPTY_ERROR: (tableName: string) => string;
+export declare const REFERENCE_DNE_ERROR: (columnName: string) => string;
+export declare const SEED_DEFAULT_EXPORT_ERROR: (fileName: string) => string;

package/dist/runtime/errors.js

@@ -0,0 +1,31 @@
+import { bold, red } from "kleur/colors";
+const FOREIGN_KEY_DNE_ERROR = (tableName) => {
+  return `Table ${bold(
+    tableName
+  )} references a table that does not exist. Did you apply the referenced table to the \`tables\` object in your db config?`;
+};
+const FOREIGN_KEY_REFERENCES_LENGTH_ERROR = (tableName) => {
+  return `Foreign key on ${bold(
+    tableName
+  )} is misconfigured. \`columns\` and \`references\` must be the same length.`;
+};
+const FOREIGN_KEY_REFERENCES_EMPTY_ERROR = (tableName) => {
+  return `Foreign key on ${bold(
+    tableName
+  )} is misconfigured. \`references\` array cannot be empty.`;
+};
+const REFERENCE_DNE_ERROR = (columnName) => {
+  return `Column ${bold(
+    columnName
+  )} references a table that does not exist. Did you apply the referenced table to the \`tables\` object in your db config?`;
+};
+const SEED_DEFAULT_EXPORT_ERROR = (fileName) => {
+  return `Missing default function export in ${bold(fileName)}`;
+};
+export {
+  FOREIGN_KEY_DNE_ERROR,
+  FOREIGN_KEY_REFERENCES_EMPTY_ERROR,
+  FOREIGN_KEY_REFERENCES_LENGTH_ERROR,
+  REFERENCE_DNE_ERROR,
+  SEED_DEFAULT_EXPORT_ERROR
+};

package/dist/runtime/index.d.ts

@@ -0,0 +1,26 @@
+import { type ColumnDataType } from 'drizzle-orm';
+import { type DBColumn, type DBTable } from '../core/types.js';
+export type { Table } from './types.js';
+export { createRemoteDatabaseClient, createLocalDatabaseClient } from './db-client.js';
+export { seedLocal } from './seed-local.js';
+export declare function hasPrimaryKey(column: DBColumn): boolean;
+export declare function asDrizzleTable(name: string, table: DBTable): 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>;
+    };
+    dialect: "sqlite";
+}>;
+export declare function normalizeDatabaseUrl(envDbUrl: string | undefined, defaultDbUrl: string): string;

package/dist/runtime/index.js

@@ -0,0 +1,131 @@
+import { pathToFileURL } from "url";
+import { sql } from "drizzle-orm";
+import {
+  customType,
+  index,
+  integer,
+  sqliteTable,
+  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 "./seed-local.js";
+function hasPrimaryKey(column) {
+  return "primaryKey" in column.schema && !!column.schema.primaryKey;
+}
+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);
+  }
+});
+function asDrizzleTable(name, table) {
+  const columns = {};
+  if (!Object.entries(table.columns).some(([, column]) => hasPrimaryKey(column))) {
+    columns["_id"] = integer("_id").primaryKey();
+  }
+  for (const [columnName, column] of Object.entries(table.columns)) {
+    columns[columnName] = columnMapper(columnName, column);
+  }
+  const drizzleTable = sqliteTable(name, columns, (ormTable) => {
+    const 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))
+        continue;
+      indexes[indexName] = index(indexName).on(...onCols);
+    }
+    return indexes;
+  });
+  return drizzleTable;
+}
+function atLeastOne(arr) {
+  return arr.length > 0;
+}
+function columnMapper(columnName, column) {
+  let c;
+  switch (column.type) {
+    case "text": {
+      c = text(columnName);
+      if (column.schema.default !== void 0)
+        c = c.default(handleSerializedSQL(column.schema.default));
+      if (column.schema.primaryKey === true)
+        c = c.primaryKey();
+      break;
+    }
+    case "number": {
+      c = integer(columnName);
+      if (column.schema.default !== void 0)
+        c = c.default(handleSerializedSQL(column.schema.default));
+      if (column.schema.primaryKey === true)
+        c = c.primaryKey();
+      break;
+    }
+    case "boolean": {
+      c = integer(columnName, { mode: "boolean" });
+      if (column.schema.default !== void 0)
+        c = c.default(handleSerializedSQL(column.schema.default));
+      break;
+    }
+    case "json":
+      c = jsonType(columnName);
+      if (column.schema.default !== void 0)
+        c = c.default(column.schema.default);
+      break;
+    case "date": {
+      c = dateType(columnName);
+      if (column.schema.default !== void 0) {
+        const def = handleSerializedSQL(column.schema.default);
+        c = c.default(typeof def === "string" ? new Date(def) : def);
+      }
+      break;
+    }
+  }
+  if (!column.schema.optional)
+    c = c.notNull();
+  if (column.schema.unique)
+    c = c.unique();
+  return c;
+}
+function handleSerializedSQL(def) {
+  if (isSerializedSQL(def)) {
+    return sql.raw(def.sql);
+  }
+  return def;
+}
+function normalizeDatabaseUrl(envDbUrl, defaultDbUrl) {
+  if (envDbUrl) {
+    if (envDbUrl.startsWith("file://")) {
+      return envDbUrl;
+    }
+    return new URL(envDbUrl, pathToFileURL(process.cwd())).toString();
+  } else {
+    return defaultDbUrl;
+  }
+}
+export {
+  asDrizzleTable,
+  createLocalDatabaseClient,
+  createRemoteDatabaseClient,
+  hasPrimaryKey,
+  normalizeDatabaseUrl,
+  seedLocal
+};

package/dist/runtime/queries.d.ts

@@ -0,0 +1,71 @@
+import type { BooleanColumn, ColumnType, DBColumn, DBTable, DateColumn, JsonColumn, NumberColumn, TextColumn } from '../core/types.js';
+export declare const SEED_DEV_FILE_NAME: string[];
+export declare function getDropTableIfExistsQuery(tableName: string): 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): {
+    type: "number";
+    schema: ({
+        unique: boolean;
+        deprecated: boolean;
+        name?: string | undefined;
+        label?: string | undefined;
+        collection?: string | undefined;
+    } & {
+        optional: boolean;
+        primaryKey: false;
+        default?: number | import("./types.js").SerializedSQL | undefined;
+    } & {
+        references?: any | undefined;
+    }) | ({
+        unique: boolean;
+        deprecated: boolean;
+        name?: string | undefined;
+        label?: string | undefined;
+        collection?: string | undefined;
+    } & {
+        primaryKey: true;
+        optional?: false | undefined;
+        default?: undefined;
+    } & {
+        references?: any | undefined;
+    });
+} | {
+    type: "text";
+    schema: ({
+        unique: boolean;
+        deprecated: boolean;
+        name?: string | undefined;
+        label?: string | undefined;
+        collection?: string | undefined;
+        default?: string | import("./types.js").SerializedSQL | undefined;
+        multiline?: boolean | undefined;
+    } & {
+        optional: boolean;
+        primaryKey: false;
+    } & {
+        references?: any | undefined;
+    }) | ({
+        unique: boolean;
+        deprecated: boolean;
+        name?: string | undefined;
+        label?: string | undefined;
+        collection?: string | undefined;
+        default?: string | import("./types.js").SerializedSQL | undefined;
+        multiline?: boolean | undefined;
+    } & {
+        primaryKey: true;
+        optional?: false | undefined;
+    } & {
+        references?: any | undefined;
+    });
+} | undefined;
+type WithDefaultDefined<T extends DBColumn> = T & {
+    schema: Required<Pick<T['schema'], 'default'>>;
+};
+type DBColumnWithDefault = WithDefaultDefined<TextColumn> | WithDefaultDefined<DateColumn> | WithDefaultDefined<NumberColumn> | WithDefaultDefined<BooleanColumn> | WithDefaultDefined<JsonColumn>;
+export declare function hasDefault(column: DBColumn): column is DBColumnWithDefault;
+export {};

package/dist/runtime/queries.js

@@ -0,0 +1,169 @@
+import {} from "drizzle-orm";
+import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
+import { bold } from "kleur/colors";
+import {
+  FOREIGN_KEY_DNE_ERROR,
+  FOREIGN_KEY_REFERENCES_EMPTY_ERROR,
+  FOREIGN_KEY_REFERENCES_LENGTH_ERROR,
+  REFERENCE_DNE_ERROR
+} from "./errors.js";
+import { hasPrimaryKey } from "./index.js";
+import { isSerializedSQL } from "./types.js";
+const sqlite = new SQLiteAsyncDialect();
+const SEED_DEV_FILE_NAME = ["seed.ts", "seed.js", "seed.mjs", "seed.mts"];
+function getDropTableIfExistsQuery(tableName) {
+  return `DROP TABLE IF EXISTS ${sqlite.escapeName(tableName)}`;
+}
+function getCreateTableQuery(tableName, table) {
+  let query = `CREATE TABLE ${sqlite.escapeName(tableName)} (`;
+  const colQueries = [];
+  const colHasPrimaryKey = Object.entries(table.columns).find(
+    ([, column]) => hasPrimaryKey(column)
+  );
+  if (!colHasPrimaryKey) {
+    colQueries.push("_id INTEGER PRIMARY KEY");
+  }
+  for (const [columnName, column] of Object.entries(table.columns)) {
+    const colQuery = `${sqlite.escapeName(columnName)} ${schemaTypeToSqlType(
+      column.type
+    )}${getModifiers(columnName, column)}`;
+    colQueries.push(colQuery);
+  }
+  colQueries.push(...getCreateForeignKeyQueries(tableName, table));
+  query += colQueries.join(", ") + ")";
+  return query;
+}
+function getCreateIndexQueries(tableName, table) {
+  let queries = [];
+  for (const [indexName, indexProps] of Object.entries(table.indexes ?? {})) {
+    const onColNames = asArray(indexProps.on);
+    const onCols = onColNames.map((colName) => sqlite.escapeName(colName));
+    const unique = indexProps.unique ? "UNIQUE " : "";
+    const indexQuery = `CREATE ${unique}INDEX ${sqlite.escapeName(
+      indexName
+    )} ON ${sqlite.escapeName(tableName)} (${onCols.join(", ")})`;
+    queries.push(indexQuery);
+  }
+  return queries;
+}
+function getCreateForeignKeyQueries(tableName, table) {
+  let queries = [];
+  for (const foreignKey of table.foreignKeys ?? []) {
+    const columns = asArray(foreignKey.columns);
+    const references = asArray(foreignKey.references);
+    if (columns.length !== references.length) {
+      throw new Error(FOREIGN_KEY_REFERENCES_LENGTH_ERROR(tableName));
+    }
+    const firstReference = references[0];
+    if (!firstReference) {
+      throw new Error(FOREIGN_KEY_REFERENCES_EMPTY_ERROR(tableName));
+    }
+    const referencedTable = firstReference.schema.collection;
+    if (!referencedTable) {
+      throw new Error(FOREIGN_KEY_DNE_ERROR(tableName));
+    }
+    const query = `FOREIGN KEY (${columns.map((f) => sqlite.escapeName(f)).join(", ")}) REFERENCES ${sqlite.escapeName(referencedTable)}(${references.map((r) => sqlite.escapeName(r.schema.name)).join(", ")})`;
+    queries.push(query);
+  }
+  return queries;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+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 (hasPrimaryKey(column)) {
+    return " PRIMARY KEY";
+  }
+  if (!column.schema.optional) {
+    modifiers += " NOT NULL";
+  }
+  if (column.schema.unique) {
+    modifiers += " UNIQUE";
+  }
+  if (hasDefault(column)) {
+    modifiers += ` DEFAULT ${getDefaultValueSql(columnName, column)}`;
+  }
+  const references = getReferencesConfig(column);
+  if (references) {
+    const { collection: tableName, name } = references.schema;
+    if (!tableName || !name) {
+      throw new Error(REFERENCE_DNE_ERROR(columnName));
+    }
+    modifiers += ` REFERENCES ${sqlite.escapeName(tableName)} (${sqlite.escapeName(name)})`;
+  }
+  return modifiers;
+}
+function getReferencesConfig(column) {
+  const canHaveReferences = column.type === "number" || column.type === "text";
+  if (!canHaveReferences)
+    return void 0;
+  return column.schema.references;
+}
+function hasDefault(column) {
+  if (column.schema.default !== void 0) {
+    return true;
+  }
+  if (hasPrimaryKey(column) && column.type === "number") {
+    return true;
+  }
+  return false;
+}
+function toDefault(def) {
+  const type = typeof def;
+  if (type === "string") {
+    return sqlite.escapeString(def);
+  } else if (type === "boolean") {
+    return def ? "TRUE" : "FALSE";
+  } else {
+    return def + "";
+  }
+}
+function getDefaultValueSql(columnName, column) {
+  if (isSerializedSQL(column.schema.default)) {
+    return column.schema.default.sql;
+  }
+  switch (column.type) {
+    case "boolean":
+    case "number":
+    case "text":
+    case "date":
+      return toDefault(column.schema.default);
+    case "json": {
+      let stringified = "";
+      try {
+        stringified = JSON.stringify(column.schema.default);
+      } catch (e) {
+        console.log(
+          `Invalid default value for column ${bold(
+            columnName
+          )}. Defaults must be valid JSON when using the \`json()\` type.`
+        );
+        process.exit(0);
+      }
+      return sqlite.escapeString(stringified);
+    }
+  }
+}
+export {
+  SEED_DEV_FILE_NAME,
+  getCreateForeignKeyQueries,
+  getCreateIndexQueries,
+  getCreateTableQuery,
+  getDropTableIfExistsQuery,
+  getModifiers,
+  getReferencesConfig,
+  hasDefault,
+  schemaTypeToSqlType
+};

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>;