@cobinar/dalus 0.1.10 → 0.1.12

package/src/{config.js → config.mjs}

@@ -1,147 +1,147 @@
-'use strict';
-// Config discovery and credential storage for dalus.
-//
-// Project config: dalus.jsonc, dalus.toml, or dalus.json, checked in the
-// current directory in that order (first one found wins — this is the
-// exact order named in the original ask: "look for file named
-// dalus.jsonc, dalus.toml, or dalus."). Login credentials are kept
-// entirely separate, in ~/.dalus/credentials.json, same reasoning
-// Wrangler keeps its own auth out of the project directory: a project
-// config is something you'd commit; a bearer token is not.
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const toml = require('smol-toml');
-const jsonc = require('jsonc-parser');
-
-const CONFIG_FILENAMES = ['dalus.jsonc', 'dalus.toml', 'dalus.json'];
-const CREDENTIALS_DIR = path.join(os.homedir(), '.dalus');
-const CREDENTIALS_PATH = path.join(CREDENTIALS_DIR, 'credentials.json');
-
-class DalusConfigError extends Error {}
-
-/** Searches the given directory (default: cwd) for a dalus config file,
- * in the fixed priority order above. Returns { path, format } or null if
- * none exist — forge.js decides what "none found" means for the command
- * being run, this module just reports the fact. */
-function findConfigFile(dir = process.cwd()) {
-  for (const name of CONFIG_FILENAMES) {
-    const p = path.join(dir, name);
-    if (fs.existsSync(p)) {
-      return { path: p, format: path.extname(name).slice(1) };
-    }
-  }
-  return null;
-}
-
-/** Loads and parses whichever config file is found, resolving `dir`/
- * `main`/`rules`/`seed` fields in every resource entry to absolute paths
- * relative to the config file's own directory — so a project's resource
- * definitions keep working regardless of what directory `dalus forge`
- * happens to be invoked from. */
-function loadConfig(dir = process.cwd()) {
-  const found = findConfigFile(dir);
-  if (!found) {
-    throw new DalusConfigError(
-      `No dalus.jsonc, dalus.toml, or dalus.json found in ${dir}.\nRun "dalus init" to create one, or pass --pages/--workers/etc. with the other required flags directly.`,
-    );
-  }
-  const raw = fs.readFileSync(found.path, 'utf8');
-  let parsed;
-  try {
-    if (found.format === 'toml') {
-      parsed = toml.parse(raw);
-    } else {
-      const errors = [];
-      parsed = jsonc.parse(raw, errors, { allowTrailingComma: true });
-      if (errors.length > 0) {
-        throw new DalusConfigError(`Could not parse ${found.path}: ${jsonc.printParseErrorCode(errors[0].error)} near offset ${errors[0].offset}`);
-      }
-    }
-  } catch (err) {
-    if (err instanceof DalusConfigError) throw err;
-    throw new DalusConfigError(`Could not parse ${found.path}: ${err.message}`);
-  }
-
-  const baseDir = path.dirname(found.path);
-  const resolvePathFields = (entry, fields) => {
-    const out = { ...entry };
-    for (const f of fields) {
-      if (typeof out[f] === 'string') out[f] = path.resolve(baseDir, out[f]);
-    }
-    return out;
-  };
-
-  const resourceKinds = {
-    workers: ['main'],
-    pages: ['dir'],
-    storage: ['dir'],
-    database: ['seed'],
-    vault: ['rules'],
-  };
-  const normalized = { apiBase: parsed.apiBase, env: {} };
-  for (const kind of Object.keys(resourceKinds)) {
-    normalized[kind] = (parsed[kind] || []).map((e) => resolvePathFields(e, resourceKinds[kind]));
-  }
-  if (parsed.env && typeof parsed.env === 'object') {
-    for (const envName of Object.keys(parsed.env)) {
-      const envBlock = parsed.env[envName] || {};
-      normalized.env[envName] = {};
-      for (const kind of Object.keys(resourceKinds)) {
-        normalized.env[envName][kind] = (envBlock[kind] || []).map((e) => resolvePathFields(e, resourceKinds[kind]));
-      }
-    }
-  }
-  normalized.__configPath = found.path;
-  return normalized;
-}
-
-/** Applies `--env NAME`, if given: for each resource kind, an env block
- * that defines that kind REPLACES the top-level list for it; a resource
- * kind the env block doesn't mention falls back to the top-level list.
- * This is a deliberately simpler model than Wrangler's deep-merge — easy
- * to explain, easy to predict what a given --env will actually deploy. */
-function resolveEnv(config, envName) {
-  if (!envName) return config;
-  const envBlock = config.env && config.env[envName];
-  if (!envBlock) {
-    throw new DalusConfigError(`No [env.${envName}] block in ${config.__configPath}.`);
-  }
-  const merged = { ...config };
-  for (const kind of ['workers', 'pages', 'storage', 'database', 'vault']) {
-    if (envBlock[kind] && envBlock[kind].length > 0) merged[kind] = envBlock[kind];
-  }
-  return merged;
-}
-
-function loadCredentials() {
-  if (!fs.existsSync(CREDENTIALS_PATH)) return null;
-  try {
-    return JSON.parse(fs.readFileSync(CREDENTIALS_PATH, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-function saveCredentials(creds) {
-  fs.mkdirSync(CREDENTIALS_DIR, { recursive: true });
-  // Same-user-only permissions — this file holds a real bearer token.
-  fs.writeFileSync(CREDENTIALS_PATH, JSON.stringify(creds, null, 2), { mode: 0o600 });
-}
-
-function clearCredentials() {
-  if (fs.existsSync(CREDENTIALS_PATH)) fs.unlinkSync(CREDENTIALS_PATH);
-}
-
-module.exports = {
-  DalusConfigError,
-  CONFIG_FILENAMES,
-  CREDENTIALS_PATH,
-  findConfigFile,
-  loadConfig,
-  resolveEnv,
-  loadCredentials,
-  saveCredentials,
-  clearCredentials,
-};
+'use strict';
+// Config discovery and credential storage for dalus.
+//
+// Project config: dalus.jsonc, dalus.toml, or dalus.json, checked in the
+// current directory in that order (first one found wins — this is the
+// exact order named in the original ask: "look for file named
+// dalus.jsonc, dalus.toml, or dalus."). Login credentials are kept
+// entirely separate, in ~/.dalus/credentials.json, same reasoning
+// Wrangler keeps its own auth out of the project directory: a project
+// config is something you'd commit; a bearer token is not.
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import toml from 'smol-toml';
+import jsonc from 'jsonc-parser';
+
+const CONFIG_FILENAMES = ['dalus.jsonc', 'dalus.toml', 'dalus.json'];
+const CREDENTIALS_DIR = path.join(os.homedir(), '.dalus');
+const CREDENTIALS_PATH = path.join(CREDENTIALS_DIR, 'credentials.json');
+
+class DalusConfigError extends Error {}
+
+/** Searches the given directory (default: cwd) for a dalus config file,
+ * in the fixed priority order above. Returns { path, format } or null if
+ * none exist — forge.js decides what "none found" means for the command
+ * being run, this module just reports the fact. */
+function findConfigFile(dir = process.cwd()) {
+  for (const name of CONFIG_FILENAMES) {
+    const p = path.join(dir, name);
+    if (fs.existsSync(p)) {
+      return { path: p, format: path.extname(name).slice(1) };
+    }
+  }
+  return null;
+}
+
+/** Loads and parses whichever config file is found, resolving `dir`/
+ * `main`/`rules`/`seed` fields in every resource entry to absolute paths
+ * relative to the config file's own directory — so a project's resource
+ * definitions keep working regardless of what directory `dalus forge`
+ * happens to be invoked from. */
+function loadConfig(dir = process.cwd()) {
+  const found = findConfigFile(dir);
+  if (!found) {
+    throw new DalusConfigError(
+      `No dalus.jsonc, dalus.toml, or dalus.json found in ${dir}.\nRun "dalus init" to create one, or pass --pages/--workers/etc. with the other required flags directly.`,
+    );
+  }
+  const raw = fs.readFileSync(found.path, 'utf8');
+  let parsed;
+  try {
+    if (found.format === 'toml') {
+      parsed = toml.parse(raw);
+    } else {
+      const errors = [];
+      parsed = jsonc.parse(raw, errors, { allowTrailingComma: true });
+      if (errors.length > 0) {
+        throw new DalusConfigError(`Could not parse ${found.path}: ${jsonc.printParseErrorCode(errors[0].error)} near offset ${errors[0].offset}`);
+      }
+    }
+  } catch (err) {
+    if (err instanceof DalusConfigError) throw err;
+    throw new DalusConfigError(`Could not parse ${found.path}: ${err.message}`);
+  }
+
+  const baseDir = path.dirname(found.path);
+  const resolvePathFields = (entry, fields) => {
+    const out = { ...entry };
+    for (const f of fields) {
+      if (typeof out[f] === 'string') out[f] = path.resolve(baseDir, out[f]);
+    }
+    return out;
+  };
+
+  const resourceKinds = {
+    workers: ['main'],
+    pages: ['dir'],
+    storage: ['dir'],
+    database: ['seed'],
+    vault: ['rules'],
+  };
+  const normalized = { apiBase: parsed.apiBase, env: {} };
+  for (const kind of Object.keys(resourceKinds)) {
+    normalized[kind] = (parsed[kind] || []).map((e) => resolvePathFields(e, resourceKinds[kind]));
+  }
+  if (parsed.env && typeof parsed.env === 'object') {
+    for (const envName of Object.keys(parsed.env)) {
+      const envBlock = parsed.env[envName] || {};
+      normalized.env[envName] = {};
+      for (const kind of Object.keys(resourceKinds)) {
+        normalized.env[envName][kind] = (envBlock[kind] || []).map((e) => resolvePathFields(e, resourceKinds[kind]));
+      }
+    }
+  }
+  normalized.__configPath = found.path;
+  return normalized;
+}
+
+/** Applies `--env NAME`, if given: for each resource kind, an env block
+ * that defines that kind REPLACES the top-level list for it; a resource
+ * kind the env block doesn't mention falls back to the top-level list.
+ * This is a deliberately simpler model than Wrangler's deep-merge — easy
+ * to explain, easy to predict what a given --env will actually deploy. */
+function resolveEnv(config, envName) {
+  if (!envName) return config;
+  const envBlock = config.env && config.env[envName];
+  if (!envBlock) {
+    throw new DalusConfigError(`No [env.${envName}] block in ${config.__configPath}.`);
+  }
+  const merged = { ...config };
+  for (const kind of ['workers', 'pages', 'storage', 'database', 'vault']) {
+    if (envBlock[kind] && envBlock[kind].length > 0) merged[kind] = envBlock[kind];
+  }
+  return merged;
+}
+
+function loadCredentials() {
+  if (!fs.existsSync(CREDENTIALS_PATH)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(CREDENTIALS_PATH, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function saveCredentials(creds) {
+  fs.mkdirSync(CREDENTIALS_DIR, { recursive: true });
+  // Same-user-only permissions — this file holds a real bearer token.
+  fs.writeFileSync(CREDENTIALS_PATH, JSON.stringify(creds, null, 2), { mode: 0o600 });
+}
+
+function clearCredentials() {
+  if (fs.existsSync(CREDENTIALS_PATH)) fs.unlinkSync(CREDENTIALS_PATH);
+}
+
+export { 
+  DalusConfigError,
+  CONFIG_FILENAMES,
+  CREDENTIALS_PATH,
+  findConfigFile,
+  loadConfig,
+  resolveEnv,
+  loadCredentials,
+  saveCredentials,
+  clearCredentials,
+ };

package/src/forgers/{database.js → database.mjs}

@@ -1,34 +1,34 @@
-'use strict';
-const fs = require('fs');
-
-/** Deploys one Document DB collection: find-or-create by name, then
- * optionally seeds it from a local JSON file (a single object -> one
- * document, an array -> one document per entry). Seeding only ever
- * ADDS documents — it doesn't diff against or replace what's already in
- * the collection, so re-running against a collection that already has
- * the seed data creates duplicates. Fine for "seed a fresh collection
- * once"; a real sync mode (matching on some key field) would need this
- * project's documents to have a stable id convention to match against,
- * which isn't assumed here. */
-async function forgeDatabase(api, log, entry) {
-  log(`Document DB: ${entry.name}`);
-
-  let collection = await api.findByName('/database/collections', entry.name);
-  if (!collection) {
-    log(`  creating collection...`);
-    collection = await api.post('/database/collections', { name: entry.name });
-  }
-
-  if (entry.seed) {
-    const raw = JSON.parse(fs.readFileSync(entry.seed, 'utf8'));
-    const docs = Array.isArray(raw) ? raw : [raw];
-    for (const doc of docs) {
-      await api.post(`/database/collections/${collection.id}/documents`, doc);
-    }
-    log(`  seeded ${docs.length} document${docs.length === 1 ? '' : 's'} from ${entry.seed}`);
-  }
-
-  log(`  done`);
-}
-
-module.exports = { forgeDatabase };
+'use strict';
+import fs from 'fs';
+
+/** Deploys one Document DB collection: find-or-create by name, then
+ * optionally seeds it from a local JSON file (a single object -> one
+ * document, an array -> one document per entry). Seeding only ever
+ * ADDS documents — it doesn't diff against or replace what's already in
+ * the collection, so re-running against a collection that already has
+ * the seed data creates duplicates. Fine for "seed a fresh collection
+ * once"; a real sync mode (matching on some key field) would need this
+ * project's documents to have a stable id convention to match against,
+ * which isn't assumed here. */
+async function forgeDatabase(api, log, entry) {
+  log(`Document DB: ${entry.name}`);
+
+  let collection = await api.findByName('/database/collections', entry.name);
+  if (!collection) {
+    log(`  creating collection...`);
+    collection = await api.post('/database/collections', { name: entry.name });
+  }
+
+  if (entry.seed) {
+    const raw = JSON.parse(fs.readFileSync(entry.seed, 'utf8'));
+    const docs = Array.isArray(raw) ? raw : [raw];
+    for (const doc of docs) {
+      await api.post(`/database/collections/${collection.id}/documents`, doc);
+    }
+    log(`  seeded ${docs.length} document${docs.length === 1 ? '' : 's'} from ${entry.seed}`);
+  }
+
+  log(`  done`);
+}
+
+export {  forgeDatabase  };

package/src/forgers/{pages.js → pages.mjs}

@@ -1,35 +1,35 @@
-'use strict';
-const fs = require('fs');
-const path = require('path');
-const { walkFiles, guessContentType } = require('../fs-utils');
-
-/** Deploys one Static Hosting project: find-or-create by name, then PUT
- * every file under `dir`. Uploads are NOT diffed against what's already
- * there — every file in `dir` is re-uploaded every run, matching how
- * `wrangler pages deploy` treats a deploy as a fresh snapshot rather
- * than an incremental sync. Stale files left over from a previous
- * deploy (renamed/removed locally) are not currently cleaned up — worth
- * a `--clean` flag later if that turns out to matter in practice. */
-async function forgePages(api, log, entry) {
-  log(`Static Hosting: ${entry.name}`);
-  const files = walkFiles(entry.dir);
-  if (files.length === 0) throw new Error(`No files found in ${entry.dir}`);
-
-  let project = await api.findByName('/pages/projects', entry.name);
-  if (!project) {
-    log(`  creating project...`);
-    project = await api.post('/pages/projects', { name: entry.name });
-  }
-
-  for (const relPath of files) {
-    const fullPath = path.join(entry.dir, relPath);
-    const contentType = guessContentType(relPath);
-    const body = fs.readFileSync(fullPath);
-    await api.putRaw(`/pages/projects/${project.id}/files/${relPath}`, body, contentType);
-    log(`  uploaded ${relPath} (${contentType})`);
-  }
-
-  log(`  done -> ${project.liveUrl || project.fallbackUrl || '(live link not returned by the API)'}`);
-}
-
-module.exports = { forgePages };
+'use strict';
+import fs from 'fs';
+import path from 'path';
+import { walkFiles, guessContentType } from '../fs-utils.mjs';
+
+/** Deploys one Static Hosting project: find-or-create by name, then PUT
+ * every file under `dir`. Uploads are NOT diffed against what's already
+ * there — every file in `dir` is re-uploaded every run, matching how
+ * `wrangler pages deploy` treats a deploy as a fresh snapshot rather
+ * than an incremental sync. Stale files left over from a previous
+ * deploy (renamed/removed locally) are not currently cleaned up — worth
+ * a `--clean` flag later if that turns out to matter in practice. */
+async function forgePages(api, log, entry) {
+  log(`Static Hosting: ${entry.name}`);
+  const files = walkFiles(entry.dir);
+  if (files.length === 0) throw new Error(`No files found in ${entry.dir}`);
+
+  let project = await api.findByName('/pages/projects', entry.name);
+  if (!project) {
+    log(`  creating project...`);
+    project = await api.post('/pages/projects', { name: entry.name });
+  }
+
+  for (const relPath of files) {
+    const fullPath = path.join(entry.dir, relPath);
+    const contentType = guessContentType(relPath);
+    const body = fs.readFileSync(fullPath);
+    await api.putRaw(`/pages/projects/${project.id}/files/${relPath}`, body, contentType);
+    log(`  uploaded ${relPath} (${contentType})`);
+  }
+
+  log(`  done -> ${project.liveUrl || project.fallbackUrl || '(live link not returned by the API)'}`);
+}
+
+export {  forgePages  };

package/src/forgers/{storage.js → storage.mjs}

@@ -1,39 +1,39 @@
-'use strict';
-const fs = require('fs');
-const path = require('path');
-const { walkFiles, guessContentType } = require('../fs-utils');
-
-/** Deploys one Object Storage bucket: find-or-create by name, flips
- * public access if configured, then PUTs every file under `dir` as an
- * object keyed by its relative path — same "re-upload everything every
- * run" behavior as the Pages forger, for the same reason (matching a
- * deploy tool's usual "this directory IS the desired state" model). */
-async function forgeStorage(api, log, entry) {
-  log(`Object Storage: ${entry.name}`);
-
-  let bucket = await api.findByName('/storage/buckets', entry.name);
-  if (!bucket) {
-    log(`  creating bucket...`);
-    bucket = await api.post('/storage/buckets', { name: entry.name });
-  }
-
-  if (typeof entry.public === 'boolean' && entry.public !== bucket.publicEnabled) {
-    bucket = await api.patch(`/storage/buckets/${bucket.id}/public`, { enabled: entry.public });
-    log(`  public access -> ${entry.public}`);
-  }
-
-  if (entry.dir) {
-    const files = walkFiles(entry.dir);
-    for (const relPath of files) {
-      const fullPath = path.join(entry.dir, relPath);
-      const contentType = guessContentType(relPath);
-      const body = fs.readFileSync(fullPath);
-      const result = await api.putRaw(`/storage/buckets/${bucket.id}/objects/${relPath}`, body, contentType);
-      log(`  uploaded ${relPath}${result && result.url ? ` -> ${result.url}` : ''}`);
-    }
-  }
-
-  log(`  done`);
-}
-
-module.exports = { forgeStorage };
+'use strict';
+import fs from 'fs';
+import path from 'path';
+import { walkFiles, guessContentType } from '../fs-utils.mjs';
+
+/** Deploys one Object Storage bucket: find-or-create by name, flips
+ * public access if configured, then PUTs every file under `dir` as an
+ * object keyed by its relative path — same "re-upload everything every
+ * run" behavior as the Pages forger, for the same reason (matching a
+ * deploy tool's usual "this directory IS the desired state" model). */
+async function forgeStorage(api, log, entry) {
+  log(`Object Storage: ${entry.name}`);
+
+  let bucket = await api.findByName('/storage/buckets', entry.name);
+  if (!bucket) {
+    log(`  creating bucket...`);
+    bucket = await api.post('/storage/buckets', { name: entry.name });
+  }
+
+  if (typeof entry.public === 'boolean' && entry.public !== bucket.publicEnabled) {
+    bucket = await api.patch(`/storage/buckets/${bucket.id}/public`, { enabled: entry.public });
+    log(`  public access -> ${entry.public}`);
+  }
+
+  if (entry.dir) {
+    const files = walkFiles(entry.dir);
+    for (const relPath of files) {
+      const fullPath = path.join(entry.dir, relPath);
+      const contentType = guessContentType(relPath);
+      const body = fs.readFileSync(fullPath);
+      const result = await api.putRaw(`/storage/buckets/${bucket.id}/objects/${relPath}`, body, contentType);
+      log(`  uploaded ${relPath}${result && result.url ? ` -> ${result.url}` : ''}`);
+    }
+  }
+
+  log(`  done`);
+}
+
+export {  forgeStorage  };

package/src/forgers/{vault.js → vault.mjs}

@@ -1,27 +1,27 @@
-'use strict';
-const fs = require('fs');
-
-/** Deploys one Vault: find-or-create by name, then uploads its rules
- * text if configured. Rules are validated server-side (a real parse —
- * see lib/rules.ts in the worker project) before being saved, so a
- * syntax error in the local rules file surfaces here as a clear error,
- * not a silent deploy of broken rules. */
-async function forgeVault(api, log, entry) {
-  log(`Vault: ${entry.name}`);
-
-  let vault = await api.findByName('/vaults', entry.name);
-  if (!vault) {
-    log(`  creating vault...`);
-    vault = await api.post('/vaults', { name: entry.name });
-  }
-
-  if (entry.rules) {
-    const rules = fs.readFileSync(entry.rules, 'utf8');
-    await api.put(`/vaults/${vault.id}/rules`, { rules });
-    log(`  rules uploaded from ${entry.rules}`);
-  }
-
-  log(`  done -> data endpoint at ${vault.dataUrl || `${api.apiBase}/vault/${entry.name}`}`);
-}
-
-module.exports = { forgeVault };
+'use strict';
+import fs from 'fs';
+
+/** Deploys one Vault: find-or-create by name, then uploads its rules
+ * text if configured. Rules are validated server-side (a real parse —
+ * see lib/rules.ts in the worker project) before being saved, so a
+ * syntax error in the local rules file surfaces here as a clear error,
+ * not a silent deploy of broken rules. */
+async function forgeVault(api, log, entry) {
+  log(`Vault: ${entry.name}`);
+
+  let vault = await api.findByName('/vaults', entry.name);
+  if (!vault) {
+    log(`  creating vault...`);
+    vault = await api.post('/vaults', { name: entry.name });
+  }
+
+  if (entry.rules) {
+    const rules = fs.readFileSync(entry.rules, 'utf8');
+    await api.put(`/vaults/${vault.id}/rules`, { rules });
+    log(`  rules uploaded from ${entry.rules}`);
+  }
+
+  log(`  done -> data endpoint at ${vault.dataUrl || `${api.apiBase}/vault/${entry.name}`}`);
+}
+
+export {  forgeVault  };