@astrojs/db 0.0.0-db-export-bug-20240307130354

package/dist/runtime/queries.d.ts

@@ -0,0 +1,81 @@
+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 recreateTables({ db, tables }: {
+    db: SqliteDB;
+    tables: DBTables;
+}): Promise<void>;
+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,206 @@
+import { LibsqlError } from "@libsql/client";
+import { sql } 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,
+  SEED_ERROR
+} from "../core/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"];
+async function seedLocal({
+  db,
+  tables,
+  // Glob all potential seed files to catch renames and deletions.
+  fileGlob
+}) {
+  await recreateTables({ db, tables });
+  for (const fileName of SEED_DEV_FILE_NAME) {
+    const key = Object.keys(fileGlob).find((f) => f.endsWith(fileName));
+    if (key) {
+      await fileGlob[key]().catch((e) => {
+        if (e instanceof LibsqlError) {
+          throw new Error(SEED_ERROR(e.message));
+        }
+        throw e;
+      });
+      return;
+    }
+  }
+}
+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))
+  ]);
+}
+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,
+  recreateTables,
+  schemaTypeToSqlType,
+  seedLocal
+};

package/dist/runtime/types.d.ts

@@ -0,0 +1,69 @@
+import type { ColumnBaseConfig, ColumnDataType } from 'drizzle-orm';
+import type { SQLiteColumn, SQLiteTableWithColumns } from 'drizzle-orm/sqlite-core';
+import type { ColumnsConfig, DBColumn, OutputColumnsConfig } from '../core/types.js';
+type GeneratedConfig<T extends ColumnDataType = ColumnDataType> = Pick<ColumnBaseConfig<T, string>, 'name' | 'tableName' | 'notNull' | 'hasDefault'>;
+export type AstroText<T extends GeneratedConfig<'string'>> = SQLiteColumn<T & {
+    data: string;
+    dataType: 'string';
+    columnType: 'SQLiteText';
+    driverParam: string;
+    enumValues: never;
+    baseColumn: never;
+}>;
+export type AstroDate<T extends GeneratedConfig<'custom'>> = SQLiteColumn<T & {
+    data: Date;
+    dataType: 'custom';
+    columnType: 'SQLiteCustomColumn';
+    driverParam: string;
+    enumValues: never;
+    baseColumn: never;
+}>;
+export type AstroBoolean<T extends GeneratedConfig<'boolean'>> = SQLiteColumn<T & {
+    data: boolean;
+    dataType: 'boolean';
+    columnType: 'SQLiteBoolean';
+    driverParam: number;
+    enumValues: never;
+    baseColumn: never;
+}>;
+export type AstroNumber<T extends GeneratedConfig<'number'>> = SQLiteColumn<T & {
+    data: number;
+    dataType: 'number';
+    columnType: 'SQLiteInteger';
+    driverParam: number;
+    enumValues: never;
+    baseColumn: never;
+}>;
+export type AstroJson<T extends GeneratedConfig<'custom'>> = SQLiteColumn<T & {
+    data: unknown;
+    dataType: 'custom';
+    columnType: 'SQLiteCustomColumn';
+    driverParam: string;
+    enumValues: never;
+    baseColumn: never;
+}>;
+export type Column<T extends DBColumn['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, TColumns extends OutputColumnsConfig | ColumnsConfig> = SQLiteTableWithColumns<{
+    name: TTableName;
+    schema: undefined;
+    dialect: 'sqlite';
+    columns: {
+        [K in Extract<keyof TColumns, string>]: Column<TColumns[K]['type'], {
+            tableName: TTableName;
+            name: K;
+            hasDefault: TColumns[K]['schema'] extends {
+                default: NonNullable<unknown>;
+            } ? true : TColumns[K]['schema'] extends {
+                primaryKey: true;
+            } ? true : false;
+            notNull: TColumns[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/dist/utils.d.ts

@@ -0,0 +1 @@
+export { asDrizzleTable } from './runtime/index.js';

package/dist/utils.js

@@ -0,0 +1,4 @@
+import { asDrizzleTable } from "./runtime/index.js";
+export {
+  asDrizzleTable
+};

package/index.d.ts

@@ -0,0 +1,3 @@
+import './virtual.js';
+
+export { default, cli } from './dist/index.js';

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@astrojs/db",
+  "version": "0.0.0-db-export-bug-20240307130354",
+  "description": "",
+  "license": "MIT",
+  "type": "module",
+  "author": "withastro",
+  "types": "./index.d.ts",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./utils": {
+      "types": "./dist/utils.d.ts",
+      "import": "./dist/utils.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime/index.d.ts",
+      "import": "./dist/runtime/index.js"
+    },
+    "./runtime/config": {
+      "types": "./dist/runtime/config.d.ts",
+      "import": "./dist/runtime/config.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./index.d.ts"
+      ],
+      "utils": [
+        "./dist/utils.d.ts"
+      ],
+      "runtime": [
+        "./dist/runtime/index.d.ts"
+      ],
+      "runtime/config": [
+        "./dist/runtime/config.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "index.d.ts",
+    "virtual.d.ts",
+    "dist"
+  ],
+  "keywords": [
+    "withastro",
+    "astro-integration"
+  ],
+  "dependencies": {
+    "@libsql/client": "^0.4.3",
+    "async-listen": "^3.0.1",
+    "deep-diff": "^1.0.2",
+    "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",
+    "strip-ansi": "^7.1.0",
+    "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/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",
+    "typescript": "^5.2.2",
+    "vite": "^5.1.4",
+    "astro": "0.0.0-db-export-bug-20240307130354",
+    "astro-scripts": "0.0.14"
+  },
+  "scripts": {
+    "build": "astro-scripts build \"src/**/*.ts\" && tsc",
+    "build:ci": "astro-scripts build \"src/**/*.ts\"",
+    "dev": "astro-scripts dev \"src/**/*.ts\"",
+    "test": "mocha --exit --timeout 20000 \"test/*.js\" \"test/unit/**/*.js\"",
+    "test:match": "mocha --timeout 20000 \"test/*.js\" \"test/unit/*.js\" -g"
+  }
+}

package/virtual.d.ts

@@ -0,0 +1,9 @@
+declare module 'astro:db' {
+	export const sql: typeof import('./dist/runtime/config.js').sql;
+	export const NOW: typeof import('./dist/runtime/config.js').NOW;
+	export const TRUE: typeof import('./dist/runtime/config.js').TRUE;
+	export const FALSE: typeof import('./dist/runtime/config.js').FALSE;
+	export const column: typeof import('./dist/runtime/config.js').column;
+	export const defineDB: typeof import('./dist/runtime/config.js').defineDB;
+	export const defineTable: typeof import('./dist/runtime/config.js').defineTable;
+}