dineway 0.1.3

package/dist/db/index.d.mts

@@ -0,0 +1,4 @@
+import "../types-DkvMXalq.mjs";
+import { i as runMigrations, n as getMigrationStatus, r as rollbackMigration, t as MigrationStatus } from "../runner-B5l1JfOj.mjs";
+import { a as SqliteConfig, c as sqlite, i as PostgresConfig, n as DatabaseDialectType, o as libsql, r as LibsqlConfig, s as postgres, t as DatabaseDescriptor } from "../adapters-BlzWJG82.mjs";
+export { type DatabaseDescriptor, type DatabaseDialectType, type LibsqlConfig, type MigrationStatus, type PostgresConfig, type SqliteConfig, getMigrationStatus, libsql, postgres, rollbackMigration, runMigrations, sqlite };

package/dist/db/index.mjs

@@ -0,0 +1,62 @@
+import "../dialect-helpers-B9uSp2GJ.mjs";
+import { n as rollbackMigration, r as runMigrations, t as getMigrationStatus } from "../runner-BGUGywgG.mjs";
+
+//#region src/db/adapters.ts
+/**
+* SQLite database adapter (better-sqlite3)
+*
+* For local development and Node.js deployments.
+*
+* @example
+* ```ts
+* database: sqlite({ url: "file:./data.db" })
+* ```
+*/
+function sqlite(config) {
+	return {
+		entrypoint: "dineway/db/sqlite",
+		config,
+		type: "sqlite"
+	};
+}
+/**
+* libSQL database adapter
+*
+* For remote libSQL deployments, with file-backed local development falling
+* back to the local SQLite dialect automatically.
+*
+* @example
+* ```ts
+* database: libsql({
+*   url: process.env.DINEWAY_DATABASE_URL || "file:./data.db",
+*   authToken: process.env.DINEWAY_DATABASE_AUTH_TOKEN,
+* })
+* ```
+*/
+function libsql(config) {
+	return {
+		entrypoint: "dineway/db/libsql",
+		config,
+		type: "sqlite"
+	};
+}
+/**
+* PostgreSQL database adapter
+*
+* For PostgreSQL deployments with connection pooling.
+*
+* @example
+* ```ts
+* database: postgres({ connectionString: process.env.DATABASE_URL })
+* ```
+*/
+function postgres(config) {
+	return {
+		entrypoint: "dineway/db/postgres",
+		config,
+		type: "postgres"
+	};
+}
+
+//#endregion
+export { getMigrationStatus, libsql, postgres, rollbackMigration, runMigrations, sqlite };

package/dist/db/libsql.d.mts

@@ -0,0 +1,10 @@
+import { r as LibsqlConfig } from "../adapters-BlzWJG82.mjs";
+import { Dialect } from "kysely";
+
+//#region src/db/libsql.d.ts
+/**
+ * Create a libSQL dialect from config
+ */
+declare function createDialect(config: LibsqlConfig): Dialect;
+//#endregion
+export { createDialect };

package/dist/db/libsql.mjs

@@ -0,0 +1,21 @@
+import { n as __require } from "../chunk-ClPoSABd.mjs";
+
+//#region src/db/libsql.ts
+/**
+* Create a libSQL dialect from config
+*/
+function createDialect(config) {
+	if (config.url === ":memory:" || config.url.startsWith("file:")) {
+		const BetterSqlite3 = __require("better-sqlite3");
+		const { SqliteDialect } = __require("kysely");
+		return new SqliteDialect({ database: new BetterSqlite3(config.url === ":memory:" ? config.url : config.url.slice(5)) });
+	}
+	const { LibsqlDialect } = __require("@libsql/kysely-libsql");
+	return new LibsqlDialect({
+		url: config.url,
+		authToken: config.authToken
+	});
+}
+
+//#endregion
+export { createDialect };

package/dist/db/postgres.d.mts

@@ -0,0 +1,10 @@
+import { i as PostgresConfig } from "../adapters-BlzWJG82.mjs";
+import { PostgresDialect } from "kysely";
+
+//#region src/db/postgres.d.ts
+/**
+ * Create a PostgreSQL dialect from config
+ */
+declare function createDialect(config: PostgresConfig): PostgresDialect;
+//#endregion
+export { createDialect };

package/dist/db/postgres.mjs

@@ -0,0 +1,29 @@
+import { PostgresDialect } from "kysely";
+import { Pool } from "pg";
+
+//#region src/db/postgres.ts
+/**
+* PostgreSQL runtime adapter
+*
+* Creates a Kysely dialect for PostgreSQL via pg.
+* Loaded at runtime via virtual module.
+*/
+/**
+* Create a PostgreSQL dialect from config
+*/
+function createDialect(config) {
+	return new PostgresDialect({ pool: new Pool({
+		connectionString: config.connectionString,
+		host: config.host,
+		port: config.port,
+		database: config.database,
+		user: config.user,
+		password: config.password,
+		ssl: config.ssl,
+		min: config.pool?.min ?? 0,
+		max: config.pool?.max ?? 10
+	}) });
+}
+
+//#endregion
+export { createDialect };

package/dist/db/sqlite.d.mts

@@ -0,0 +1,10 @@
+import { a as SqliteConfig } from "../adapters-BlzWJG82.mjs";
+import { Dialect } from "kysely";
+
+//#region src/db/sqlite.d.ts
+/**
+ * Create a SQLite dialect from config
+ */
+declare function createDialect(config: SqliteConfig): Dialect;
+//#endregion
+export { createDialect };

package/dist/db/sqlite.mjs

@@ -0,0 +1,15 @@
+import { n as __require } from "../chunk-ClPoSABd.mjs";
+
+//#region src/db/sqlite.ts
+/**
+* Create a SQLite dialect from config
+*/
+function createDialect(config) {
+	const BetterSqlite3 = __require("better-sqlite3");
+	const { SqliteDialect } = __require("kysely");
+	const url = config.url;
+	return new SqliteDialect({ database: new BetterSqlite3(url.startsWith("file:") ? url.slice(5) : url) });
+}
+
+//#endregion
+export { createDialect };

package/dist/default-WYlzADZL.mjs

@@ -0,0 +1,80 @@
+//#region src/seed/default.ts
+const defaultSeed = {
+	version: "1",
+	meta: {
+		name: "Default",
+		description: "Posts and pages with categories and tags"
+	},
+	collections: [{
+		slug: "posts",
+		label: "Posts",
+		labelSingular: "Post",
+		supports: [
+			"drafts",
+			"revisions",
+			"search"
+		],
+		fields: [
+			{
+				slug: "title",
+				label: "Title",
+				type: "string",
+				required: true,
+				searchable: true
+			},
+			{
+				slug: "featured_image",
+				label: "Featured Image",
+				type: "image"
+			},
+			{
+				slug: "content",
+				label: "Content",
+				type: "portableText",
+				searchable: true
+			},
+			{
+				slug: "excerpt",
+				label: "Excerpt",
+				type: "text"
+			}
+		]
+	}, {
+		slug: "pages",
+		label: "Pages",
+		labelSingular: "Page",
+		supports: [
+			"drafts",
+			"revisions",
+			"search"
+		],
+		fields: [{
+			slug: "title",
+			label: "Title",
+			type: "string",
+			required: true,
+			searchable: true
+		}, {
+			slug: "content",
+			label: "Content",
+			type: "portableText",
+			searchable: true
+		}]
+	}],
+	taxonomies: [{
+		name: "category",
+		label: "Categories",
+		labelSingular: "Category",
+		hierarchical: true,
+		collections: ["posts"]
+	}, {
+		name: "tag",
+		label: "Tags",
+		labelSingular: "Tag",
+		hierarchical: false,
+		collections: ["posts"]
+	}]
+};
+
+//#endregion
+export { defaultSeed as t };

package/dist/dialect-helpers-B9uSp2GJ.mjs

@@ -0,0 +1,89 @@
+import { sql } from "kysely";
+
+//#region src/database/dialect-helpers.ts
+/**
+* Detect dialect type from a Kysely instance via the adapter class name.
+*/
+function detectDialect(db) {
+	if (db.getExecutor().adapter.constructor.name === "PostgresAdapter") return "postgres";
+	return "sqlite";
+}
+function isSqlite(db) {
+	return detectDialect(db) === "sqlite";
+}
+function isPostgres(db) {
+	return detectDialect(db) === "postgres";
+}
+/**
+* Default timestamp expression for column defaults.
+* Wrapped in parens for use in CREATE TABLE ... DEFAULT (...).
+*
+* sqlite:   (datetime('now'))
+* postgres: CURRENT_TIMESTAMP
+*/
+function currentTimestamp(db) {
+	if (isPostgres(db)) return sql`CURRENT_TIMESTAMP`;
+	return sql`(datetime('now'))`;
+}
+/**
+* Timestamp expression for use in WHERE clauses and SET expressions.
+* No wrapping parens.
+*
+* sqlite:   datetime('now')
+* postgres: CURRENT_TIMESTAMP
+*/
+function currentTimestampValue(db) {
+	if (isPostgres(db)) return sql`CURRENT_TIMESTAMP`;
+	return sql`datetime('now')`;
+}
+/**
+* Check if a table exists in the database.
+*/
+async function tableExists(db, tableName) {
+	if (isPostgres(db)) return (await sql`
+			SELECT EXISTS(
+				SELECT 1 FROM information_schema.tables
+				WHERE table_schema = 'public' AND table_name = ${tableName}
+			) as exists
+		`.execute(db)).rows[0]?.exists === true;
+	return (await sql`
+		SELECT name FROM sqlite_master
+		WHERE type = 'table' AND name = ${tableName}
+	`.execute(db)).rows.length > 0;
+}
+/**
+* List tables matching a LIKE pattern.
+*/
+async function listTablesLike(db, pattern) {
+	if (isPostgres(db)) return (await sql`
+			SELECT table_name FROM information_schema.tables
+			WHERE table_schema = 'public' AND table_name LIKE ${pattern}
+		`.execute(db)).rows.map((r) => r.table_name);
+	return (await sql`
+		SELECT name FROM sqlite_master
+		WHERE type = 'table' AND name LIKE ${pattern}
+	`.execute(db)).rows.map((r) => r.name);
+}
+/**
+* Column type for binary data.
+*
+* sqlite:   blob
+* postgres: bytea
+*/
+function binaryType(db) {
+	if (isPostgres(db)) return "bytea";
+	return "blob";
+}
+/**
+* SQL expression for extracting a field from a JSON/JSONB column.
+*
+* sqlite:   json_extract(column, '$.path')
+* postgres: column->>'path'
+*/
+function jsonExtractExpr(db, column, path) {
+	if (isPostgres(db)) return `${column}->>'${path}'`;
+	return `json_extract(${column}, '$.${path}')`;
+}
+
+//#endregion
+export { isSqlite as a, tableExists as c, isPostgres as i, currentTimestamp as n, jsonExtractExpr as o, currentTimestampValue as r, listTablesLike as s, binaryType as t };

package/dist/error-DrxtnGPg.mjs

@@ -0,0 +1,26 @@
+//#region src/api/error.ts
+/**
+* Standard cache headers for all API responses.
+*
+* Cache-Control: private, no-store -- prevents CDN/proxy caching of authenticated data.
+* no-store already tells caches not to store the response, so Vary is unnecessary.
+*/
+const API_CACHE_HEADERS = { "Cache-Control": "private, no-store" };
+/**
+* Create a standardized error response.
+*
+* Always returns `{ error: { code, message } }` with correct Content-Type.
+* Use this for all error responses in API routes.
+*/
+function apiError(code, message, status) {
+	return Response.json({ error: {
+		code,
+		message
+	} }, {
+		status,
+		headers: API_CACHE_HEADERS
+	});
+}
+
+//#endregion
+export { apiError as t };