nextly 0.0.1 → 0.0.2-alpha.0

package/dist/chunk-IZWPRDC3.mjs

@@ -0,0 +1,206 @@
+import {
+  getColumnDescriptor,
+  getSystemColumnDescriptors
+} from "./chunk-DNNG377Z.mjs";
+
+// src/domains/schema/services/runtime-schema-generator.ts
+import {
+  mysqlTable,
+  text as mysqlText,
+  boolean as mysqlBoolean,
+  timestamp as mysqlTimestamp,
+  json as mysqlJson,
+  varchar as mysqlVarchar,
+  double as mysqlDouble,
+  int as mysqlInt
+} from "drizzle-orm/mysql-core";
+import {
+  pgTable,
+  text as pgText,
+  boolean as pgBoolean,
+  timestamp as pgTimestamp,
+  jsonb as pgJsonb,
+  doublePrecision as pgDoublePrecision,
+  varchar as pgVarchar,
+  integer as pgInteger
+} from "drizzle-orm/pg-core";
+import {
+  sqliteTable,
+  text as sqliteText,
+  integer as sqliteInteger,
+  real as sqliteReal
+} from "drizzle-orm/sqlite-core";
+function generateRuntimeSchema(tableName, fields, dialect, options = {}) {
+  let table;
+  switch (dialect) {
+    case "postgresql":
+      table = generatePostgresSchema(tableName, fields, options);
+      break;
+    case "mysql":
+      table = generateMySQLSchema(tableName, fields, options);
+      break;
+    case "sqlite":
+      table = generateSQLiteSchema(tableName, fields, options);
+      break;
+    default:
+      throw new Error(`Unsupported dialect: ${String(dialect)}`);
+  }
+  return {
+    table,
+    schemaRecord: { [tableName]: table }
+  };
+}
+function generatePostgresSchema(tableName, fields, options) {
+  const columns = buildDrizzleColumnRecord(fields, "postgresql", options);
+  return pgTable(tableName, columns);
+}
+function generateMySQLSchema(tableName, fields, options) {
+  const columns = buildDrizzleColumnRecord(fields, "mysql", options);
+  return mysqlTable(tableName, columns);
+}
+function generateSQLiteSchema(tableName, fields, options) {
+  const columns = buildDrizzleColumnRecord(fields, "sqlite", options);
+  return sqliteTable(tableName, columns);
+}
+function buildDrizzleColumnRecord(fields, dialect, options = {}) {
+  const out = {};
+  const hasTitleField = fields.some((f) => f.name === "title");
+  const hasSlugField = fields.some((f) => f.name === "slug");
+  for (const sys of getSystemColumnDescriptors(dialect, {
+    hasTitleField,
+    hasSlugField,
+    hasStatus: options.status === true
+  })) {
+    out[sys.name] = buildSystemDrizzleColumn(sys, dialect);
+  }
+  for (const field of fields) {
+    const desc = getColumnDescriptor(field, dialect);
+    if (!desc) continue;
+    out[field.name] = buildUserDrizzleColumn(desc, dialect);
+  }
+  return out;
+}
+function buildSystemDrizzleColumn(sys, dialect) {
+  if (dialect === "postgresql") {
+    if (sys.name === "id") return pgText("id").primaryKey();
+    if (sys.name === "created_at") return pgTimestamp("created_at").defaultNow();
+    if (sys.name === "updated_at") return pgTimestamp("updated_at").defaultNow();
+    if (sys.name === "status") {
+      return pgVarchar("status", { length: 20 }).notNull().default("draft");
+    }
+    return pgText(sys.name).notNull();
+  }
+  if (dialect === "mysql") {
+    if (sys.name === "id") {
+      return mysqlVarchar("id", { length: 36 }).primaryKey();
+    }
+    if (sys.name === "created_at") {
+      return mysqlTimestamp("created_at").defaultNow();
+    }
+    if (sys.name === "updated_at") {
+      return mysqlTimestamp("updated_at").defaultNow();
+    }
+    if (sys.name === "status") {
+      return mysqlVarchar("status", { length: 20 }).notNull().default("draft");
+    }
+    return mysqlVarchar(sys.name, { length: 255 }).notNull();
+  }
+  if (sys.name === "id") return sqliteText("id").primaryKey();
+  if (sys.name === "created_at") {
+    return sqliteInteger("created_at", { mode: "timestamp" });
+  }
+  if (sys.name === "updated_at") {
+    return sqliteInteger("updated_at", { mode: "timestamp" });
+  }
+  if (sys.name === "status") {
+    return sqliteText("status").notNull().default("draft");
+  }
+  return sqliteText(sys.name).notNull();
+}
+function buildUserDrizzleColumn(desc, dialect) {
+  if (dialect === "postgresql") {
+    return buildPgColumnFromKind(desc.kind, desc.name, desc.nullable);
+  }
+  if (dialect === "mysql") {
+    return buildMysqlColumnFromKind(
+      desc.kind,
+      desc.name,
+      desc.nullable,
+      desc.length
+    );
+  }
+  return buildSqliteColumnFromKind(desc.kind, desc.name, desc.nullable);
+}
+function buildPgColumnFromKind(kind, name, nullable) {
+  switch (kind) {
+    case "text":
+    case "longText":
+    case "varchar":
+      return nullable ? pgText(name) : pgText(name).notNull();
+    case "boolean":
+      return nullable ? pgBoolean(name) : pgBoolean(name).notNull();
+    case "integer":
+      return nullable ? pgInteger(name) : pgInteger(name).notNull();
+    case "double":
+      return nullable ? pgDoublePrecision(name) : pgDoublePrecision(name).notNull();
+    case "timestamp":
+      return nullable ? pgTimestamp(name) : pgTimestamp(name).notNull();
+    case "json":
+      return nullable ? pgJsonb(name) : pgJsonb(name).notNull();
+    case "fkSingle":
+      return pgText(name);
+    case "skip":
+      return null;
+  }
+}
+function buildMysqlColumnFromKind(kind, name, nullable, length) {
+  switch (kind) {
+    case "text":
+    case "varchar": {
+      const col = mysqlVarchar(name, { length: length ?? 255 });
+      return nullable ? col : col.notNull();
+    }
+    case "longText":
+      return nullable ? mysqlText(name) : mysqlText(name).notNull();
+    case "boolean":
+      return nullable ? mysqlBoolean(name) : mysqlBoolean(name).notNull();
+    case "integer":
+      return nullable ? mysqlInt(name) : mysqlInt(name).notNull();
+    case "double":
+      return nullable ? mysqlDouble(name) : mysqlDouble(name).notNull();
+    case "timestamp":
+      return nullable ? mysqlTimestamp(name) : mysqlTimestamp(name).notNull();
+    case "json":
+      return nullable ? mysqlJson(name) : mysqlJson(name).notNull();
+    case "fkSingle":
+      return mysqlVarchar(name, { length: length ?? 36 });
+    case "skip":
+      return null;
+  }
+}
+function buildSqliteColumnFromKind(kind, name, nullable) {
+  switch (kind) {
+    case "text":
+    case "longText":
+    case "varchar":
+      return nullable ? sqliteText(name) : sqliteText(name).notNull();
+    case "boolean":
+      return nullable ? sqliteInteger(name, { mode: "boolean" }) : sqliteInteger(name, { mode: "boolean" }).notNull();
+    case "integer":
+      return nullable ? sqliteInteger(name) : sqliteInteger(name).notNull();
+    case "double":
+      return nullable ? sqliteReal(name) : sqliteReal(name).notNull();
+    case "timestamp":
+      return nullable ? sqliteInteger(name, { mode: "timestamp" }) : sqliteInteger(name, { mode: "timestamp" }).notNull();
+    case "json":
+      return nullable ? sqliteText(name) : sqliteText(name).notNull();
+    case "fkSingle":
+      return sqliteText(name);
+    case "skip":
+      return null;
+  }
+}
+
+export {
+  generateRuntimeSchema
+};

package/dist/chunk-KIMNCZGV.mjs

@@ -0,0 +1,15 @@
+// src/domains/schema/pipeline/database-url.ts
+function extractDatabaseNameFromUrl(url) {
+  if (!url) return void 0;
+  try {
+    const parsed = new URL(url);
+    const name = parsed.pathname.replace(/^\//, "");
+    return name.length > 0 ? name : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+export {
+  extractDatabaseNameFromUrl
+};

package/dist/chunk-L6HW2DA7.mjs

@@ -0,0 +1,15 @@
+// src/domains/singles/services/reconcile-single-tables.ts
+async function reconcileSingleTables(reconciler) {
+  const [registered, existing] = await Promise.all([
+    reconciler.registeredSingles(),
+    reconciler.existingTableNames()
+  ]);
+  for (const single of registered) {
+    if (existing.has(single.tableName)) continue;
+    await reconciler.createTable(single);
+  }
+}
+
+export {
+  reconcileSingleTables
+};

package/dist/chunk-LAZXX4HR.mjs

@@ -0,0 +1,100 @@
+import {
+  container
+} from "./chunk-D5HQBNUB.mjs";
+
+// src/shared/lib/logger.ts
+var levelPriority = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+var DB_LOG_ENABLED = false;
+var DB_LOG_LEVEL = "warn";
+function isEnabled(level) {
+  if (!DB_LOG_ENABLED) return false;
+  if (DB_LOG_LEVEL === "silent") return false;
+  if (level === "silent") return false;
+  const current = levelPriority[DB_LOG_LEVEL];
+  const req = levelPriority[level];
+  return req >= current;
+}
+var DefaultDbLogger = class {
+  log(level, event) {
+    if (!isEnabled(level)) return;
+    const timeIso = (/* @__PURE__ */ new Date()).toISOString();
+    const payload = { time: timeIso, level, ...event };
+    if (level === "error") console.error("[db]", JSON.stringify(payload));
+    else if (level === "warn") console.warn("[db]", JSON.stringify(payload));
+    else console.log("[db]", JSON.stringify(payload));
+  }
+};
+var activeLogger = new DefaultDbLogger();
+function logDbConn(level, event) {
+  const full = {
+    ...event,
+    category: "connection"
+  };
+  activeLogger.log(level, full);
+}
+function nowMs() {
+  if (typeof process !== "undefined" && typeof process.hrtime === "function") {
+    const ns = process.hrtime.bigint();
+    return Number(ns / BigInt(1e6));
+  }
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return performance.now();
+  }
+  return Date.now();
+}
+var DefaultAuthLogger = class {
+  log(level, event) {
+    const timeIso = (/* @__PURE__ */ new Date()).toISOString();
+    const payload = { time: timeIso, level, ...event };
+    if (level === "error") console.error("[auth]", JSON.stringify(payload));
+    else if (level === "warn") console.warn("[auth]", JSON.stringify(payload));
+    else console.log("[auth]", JSON.stringify(payload));
+  }
+};
+var activeAuthLogger = new DefaultAuthLogger();
+function getAuthLogger() {
+  return activeAuthLogger;
+}
+
+// src/database/health.ts
+async function healthCheck() {
+  const started = nowMs();
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const adapter = container.get("adapter");
+    const dialect = adapter.getCapabilities().dialect;
+    await adapter.executeQuery("SELECT 1");
+    const latencyMs = nowMs() - started;
+    logDbConn("info", { op: "health-ok", dialect, durationMs: latencyMs });
+    return {
+      ok: true,
+      timestamp,
+      database: { connected: true, dialect, latencyMs }
+    };
+  } catch (error) {
+    const latencyMs = nowMs() - started;
+    const errorMessage = error instanceof Error ? error.message : "Unknown database error";
+    logDbConn("error", {
+      op: "health-fail",
+      dialect: "unknown",
+      durationMs: latencyMs,
+      errorMessage
+    });
+    return {
+      ok: false,
+      timestamp,
+      database: { connected: false, dialect: "unknown", latencyMs },
+      error: errorMessage
+    };
+  }
+}
+
+export {
+  getAuthLogger,
+  healthCheck
+};

package/dist/chunk-LDKCUMHK.mjs

@@ -0,0 +1,95 @@
+import {
+  isErrorResponse,
+  requireAuthentication,
+  toNextlyAuthError
+} from "./chunk-2Q2SX2CS.mjs";
+import {
+  nextlyValidationFromZod
+} from "./chunk-GJNSJU4S.mjs";
+import {
+  withErrorHandler
+} from "./chunk-TO5AFLVQ.mjs";
+import {
+  getCachedNextly
+} from "./chunk-P7NH2OSC.mjs";
+import {
+  respondAction
+} from "./chunk-IUDOC7N7.mjs";
+import {
+  container
+} from "./chunk-D5HQBNUB.mjs";
+import {
+  NextlyError
+} from "./chunk-NRUWQ5Z7.mjs";
+
+// src/api/email-send-template.ts
+import { z } from "zod";
+async function getEmailService() {
+  await getCachedNextly();
+  return container.get("emailService");
+}
+var attachmentInputSchema = z.object({
+  mediaId: z.string().min(1, "mediaId is required"),
+  filename: z.string().min(1).optional()
+});
+var sendTemplateSchema = z.object({
+  to: z.string().email("A valid recipient email is required"),
+  template: z.string().min(1, "template slug is required"),
+  variables: z.record(z.string(), z.unknown()).optional(),
+  cc: z.array(z.string().email()).optional(),
+  bcc: z.array(z.string().email()).optional(),
+  providerId: z.string().optional(),
+  attachments: z.array(attachmentInputSchema).optional()
+});
+var POST = withErrorHandler(
+  async (request) => {
+    const authResult = await requireAuthentication(request);
+    if (isErrorResponse(authResult)) throw toNextlyAuthError(authResult);
+    let raw;
+    try {
+      raw = await request.json();
+    } catch {
+      throw new NextlyError({
+        code: "VALIDATION_ERROR",
+        publicMessage: "Validation failed.",
+        publicData: {
+          errors: [
+            {
+              path: "",
+              code: "invalid_json",
+              message: "Request body is not valid JSON."
+            }
+          ]
+        },
+        logContext: { reason: "invalid-json-body" }
+      });
+    }
+    let args;
+    try {
+      args = sendTemplateSchema.parse(raw);
+    } catch (err) {
+      if (err instanceof z.ZodError) throw nextlyValidationFromZod(err);
+      throw err;
+    }
+    const service = await getEmailService();
+    const result = await service.sendWithTemplate(
+      args.template,
+      args.to,
+      args.variables ?? {},
+      {
+        providerId: args.providerId,
+        cc: args.cc,
+        bcc: args.bcc,
+        attachments: args.attachments
+      }
+    );
+    return respondAction("Email queued.", {
+      ...result,
+      templateId: args.template
+    });
+  }
+);
+
+export {
+  POST
+};

package/dist/chunk-M52VMPGA.mjs

@@ -0,0 +1,119 @@
+// src/cli/utils/adapter.ts
+function detectDialectFromUrl(url) {
+  if (url.startsWith("postgresql://") || url.startsWith("postgres://")) {
+    return "postgresql";
+  }
+  if (url.startsWith("mysql://")) {
+    return "mysql";
+  }
+  if (url.startsWith("file:") || url.endsWith(".db") || url.endsWith(".sqlite") || url.endsWith(".sqlite3")) {
+    return "sqlite";
+  }
+  return void 0;
+}
+function validateDatabaseEnv() {
+  const errors = [];
+  const databaseUrl = process.env.DATABASE_URL;
+  const dialectEnv = process.env.DB_DIALECT;
+  if (!databaseUrl) {
+    errors.push("DATABASE_URL environment variable is required");
+  }
+  let dialect = dialectEnv;
+  if (!dialect && databaseUrl) {
+    dialect = detectDialectFromUrl(databaseUrl);
+  }
+  if (!dialect) {
+    errors.push(
+      "Could not detect database dialect. Set DB_DIALECT to one of: postgresql, mysql, sqlite"
+    );
+  } else if (!["postgresql", "mysql", "sqlite"].includes(dialect)) {
+    errors.push(
+      `Invalid DB_DIALECT: ${dialect}. Must be one of: postgresql, mysql, sqlite`
+    );
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    dialect: errors.length === 0 ? dialect : void 0,
+    databaseUrl: errors.length === 0 ? databaseUrl : void 0
+  };
+}
+async function createAdapter(options = {}) {
+  const { logger } = options;
+  const databaseUrl = options.databaseUrl ?? process.env.DATABASE_URL;
+  let dialect = options.dialect;
+  if (!dialect && databaseUrl) {
+    dialect = detectDialectFromUrl(databaseUrl);
+  }
+  if (!dialect) {
+    dialect = process.env.DB_DIALECT;
+  }
+  if (!databaseUrl) {
+    throw new Error("DATABASE_URL is required");
+  }
+  if (!dialect) {
+    throw new Error(
+      "Could not detect database dialect. Set DB_DIALECT environment variable."
+    );
+  }
+  logger?.debug(`Creating ${dialect} adapter...`);
+  const { createAdapterFromEnv } = await import("./factory-IWMBKUJM.mjs");
+  const originalDialect = process.env.DB_DIALECT;
+  const originalUrl = process.env.DATABASE_URL;
+  try {
+    process.env.DB_DIALECT = dialect;
+    process.env.DATABASE_URL = databaseUrl;
+    const adapter = await createAdapterFromEnv();
+    return adapter;
+  } finally {
+    if (originalDialect !== void 0) {
+      process.env.DB_DIALECT = originalDialect;
+    }
+    if (originalUrl !== void 0) {
+      process.env.DATABASE_URL = originalUrl;
+    }
+  }
+}
+async function withAdapter(fn, options = {}) {
+  const adapter = await createAdapter(options);
+  try {
+    return await fn(adapter);
+  } finally {
+    await adapter.disconnect();
+  }
+}
+function getDialectDisplayName(dialect) {
+  switch (dialect) {
+    case "postgresql":
+      return "PostgreSQL";
+    case "mysql":
+      return "MySQL";
+    case "sqlite":
+      return "SQLite";
+    default:
+      return dialect;
+  }
+}
+function dialectSupports(dialect, feature) {
+  switch (feature) {
+    case "transactions":
+      return true;
+    case "jsonb":
+      return dialect === "postgresql";
+    case "arrays":
+      return dialect === "postgresql";
+    case "uuids":
+      return dialect === "postgresql";
+    default:
+      return false;
+  }
+}
+
+export {
+  detectDialectFromUrl,
+  validateDatabaseEnv,
+  createAdapter,
+  withAdapter,
+  getDialectDisplayName,
+  dialectSupports
+};