@holo-js/adapter-nuxt 0.1.2 → 0.1.4

package/dist/module.d.mts

@@ -1,8 +1,34 @@
 import { LoadedHoloConfig, HoloConfigMap } from '@holo-js/config';
-import { ModuleOptions as ModuleOptions$1 } from '@holo-js/storage';
 
 type ModuleOptions = Record<string, never>;
-declare function toStorageModuleOptions(loaded: LoadedHoloConfig<HoloConfigMap>): ModuleOptions$1;
+type StorageDriver = 'local' | 'public' | 's3';
+type StorageVisibility = 'private' | 'public';
+type StorageDiskConfig = {
+    driver: StorageDriver;
+    visibility?: StorageVisibility;
+    root?: string;
+    url?: string;
+    bucket?: string;
+    region?: string;
+    endpoint?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    sessionToken?: string;
+    forcePathStyleEndpoint?: boolean;
+    [key: string]: unknown;
+};
+type StorageModuleOptions = {
+    defaultDisk?: string;
+    routePrefix?: string;
+    disks?: Record<string, StorageDiskConfig>;
+};
+type StorageS3Module = {
+    default: unknown;
+};
+declare function hasModuleNotFoundCode(error: unknown, expectedSpecifier: string): boolean;
+declare function importOptionalStorageS3Module(): Promise<StorageS3Module | undefined>;
+declare function hasLoadedConfigFile(loaded: LoadedHoloConfig<HoloConfigMap>, configName: string): boolean;
+declare function toStorageModuleOptions(loaded: LoadedHoloConfig<HoloConfigMap>): StorageModuleOptions;
 declare const _default: {
     meta?: {
         name?: string;
@@ -11,9 +37,14 @@ declare const _default: {
     setup: (options: ModuleOptions, nuxt: unknown) => void | Promise<void>;
 };
 
+declare const moduleInternals: {
+    hasModuleNotFoundCode: typeof hasModuleNotFoundCode;
+    hasLoadedConfigFile: typeof hasLoadedConfigFile;
+    importOptionalStorageS3Module: typeof importOptionalStorageS3Module;
+};
 declare const adapterNuxtInternals: {
     toStorageModuleOptions: typeof toStorageModuleOptions;
 };
 
-export { adapterNuxtInternals, _default as default };
+export { adapterNuxtInternals, _default as default, moduleInternals };
 export type { ModuleOptions };

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@holo-js/adapter-nuxt",
   "configKey": "@holo-js/adapter-nuxt",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/dist/module.mjs

@@ -1,8 +1,60 @@
-import { resolve } from 'node:path';
+import { readdir, mkdir, writeFile } from 'node:fs/promises';
+import { resolve, extname, basename, relative } from 'node:path';
 import { defineNuxtModule, createResolver, addServerPlugin, addImports, addServerImportsDir, addServerHandler } from '@nuxt/kit';
 import { loadConfigDirectory } from '@holo-js/config';
-import { mergeModuleOptions, normalizeModuleOptions, applyNitroStorageConfig, hasPublicLocalDisk } from '@holo-js/storage';
 
+const MODEL_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"]);
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function hasModuleNotFoundCode(error, expectedSpecifier) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  if ("code" in error && error.code === "ERR_MODULE_NOT_FOUND") {
+    const message = "message" in error && typeof error.message === "string" ? error.message : "";
+    const escapedSpecifier = escapeRegExp(expectedSpecifier);
+    if ([
+      new RegExp(`Cannot find package ['"]${escapedSpecifier}['"]`),
+      new RegExp(`Cannot find module ['"]${escapedSpecifier}['"]`),
+      new RegExp(`Could not resolve ['"]${escapedSpecifier}['"]`),
+      new RegExp(`Failed to load url\\s+(?:['"\`]${escapedSpecifier}['"\`]|${escapedSpecifier}(?=[\\s(]|$))`)
+    ].some((pattern) => pattern.test(message))) {
+      return true;
+    }
+  }
+  if ("cause" in error) {
+    return hasModuleNotFoundCode(error.cause, expectedSpecifier);
+  }
+  return false;
+}
+async function importOptionalStorageModule() {
+  try {
+    return await import('@holo-js/storage');
+  } catch (error) {
+    if (hasModuleNotFoundCode(error, "@holo-js/storage")) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function importOptionalStorageS3Module() {
+  try {
+    const storageS3 = await import('@holo-js/storage-s3');
+    return typeof storageS3.default === "undefined" ? void 0 : storageS3;
+  } catch (error) {
+    if (hasModuleNotFoundCode(error, "@holo-js/storage-s3")) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+function hasLoadedConfigFile(loaded, configName) {
+  return loaded.loadedFiles.some((filePath) => {
+    const normalizedPath = filePath.replaceAll("\\", "/");
+    return normalizedPath.endsWith(`/config/${configName}.ts`) || normalizedPath.endsWith(`/config/${configName}.mts`) || normalizedPath.endsWith(`/config/${configName}.js`) || normalizedPath.endsWith(`/config/${configName}.mjs`) || normalizedPath.endsWith(`/config/${configName}.cts`) || normalizedPath.endsWith(`/config/${configName}.cjs`);
+  });
+}
 function toStorageModuleOptions(loaded) {
   return {
     defaultDisk: loaded.storage.defaultDisk,
@@ -10,6 +62,31 @@ function toStorageModuleOptions(loaded) {
     disks: { ...loaded.storage.disks }
   };
 }
+async function createServerModelImports(sourceDir) {
+  const modelsDir = resolve(sourceDir, "server/models");
+  const modelImportDir = resolve(sourceDir, ".holo-js/generated/nuxt-server-imports");
+  const modelImportFile = resolve(modelImportDir, "models.ts");
+  let modelFiles;
+  try {
+    modelFiles = (await readdir(modelsDir)).filter((fileName) => MODEL_FILE_EXTENSIONS.has(extname(fileName))).sort((left, right) => left.localeCompare(right));
+  } catch {
+    return null;
+  }
+  if (modelFiles.length === 0) {
+    return null;
+  }
+  const lines = modelFiles.map((fileName) => {
+    const modelName = basename(fileName, extname(fileName));
+    const importPath = relative(modelImportDir, resolve(modelsDir, fileName)).replaceAll("\\", "/");
+    const normalizedImportPath = importPath.replace(/^(?!\.)/, "./");
+    const extension = extname(normalizedImportPath);
+    return `export { default as ${modelName} } from '${normalizedImportPath.slice(0, -extension.length)}'`;
+  });
+  await mkdir(modelImportDir, { recursive: true });
+  await writeFile(modelImportFile, `${lines.join("\n")}
+`, "utf8");
+  return modelImportDir;
+}
 const module$1 = defineNuxtModule({
   meta: {
     name: "@holo-js/adapter-nuxt"
@@ -24,6 +101,7 @@ const module$1 = defineNuxtModule({
       preferCache: process.env.NODE_ENV === "production",
       processEnv: process.env
     });
+    const storageModule = await importOptionalStorageModule();
     const loadedStorageOptions = toStorageModuleOptions(loaded);
     const s3Driver = resolver.resolve("./runtime/drivers/s3.js");
     opts.nitro = opts.nitro || { storage: {} };
@@ -36,43 +114,62 @@ const module$1 = defineNuxtModule({
       projectRoot: rootDir
     };
     opts.runtimeConfig.db = loaded.database;
-    const mergedStorageOptions = mergeModuleOptions(void 0, loadedStorageOptions);
-    const normalizedStorage = normalizeModuleOptions(mergedStorageOptions);
+    const storageConfigured = hasLoadedConfigFile(loaded, "storage");
+    if (!storageModule && storageConfigured) {
+      throw new Error("[@holo-js/adapter-nuxt] Storage config requires @holo-js/storage to be installed.");
+    }
+    const mergedStorageOptions = storageModule?.mergeModuleOptions(void 0, loadedStorageOptions);
+    const normalizedStorage = mergedStorageOptions ? storageModule?.normalizeModuleOptions(mergedStorageOptions) : void 0;
     opts._holoStorageModuleOptions = mergedStorageOptions;
-    opts.runtimeConfig.holoStorage = normalizedStorage;
+    if (normalizedStorage && Object.values(normalizedStorage.disks).some((disk) => disk.driver === "s3")) {
+      if (!await importOptionalStorageS3Module()) {
+        throw new Error("[@holo-js/adapter-nuxt] S3 storage disks require @holo-js/storage-s3 to be installed.");
+      }
+    }
+    if (normalizedStorage) {
+      opts.runtimeConfig.holoStorage = normalizedStorage;
+    }
     if (!opts._holoCoreRuntimeRegistered) {
-      addServerPlugin(resolver.resolve("./runtime/plugins/init"));
-      addImports([
+      const imports = [
         { name: "holo", as: "holo", from: resolver.resolve("./runtime/composables") },
         { name: "useHoloDb", as: "useHoloDb", from: resolver.resolve("./runtime/composables") },
         { name: "useHoloEnv", as: "useHoloEnv", from: resolver.resolve("./runtime/composables") },
-        { name: "useHoloDebug", as: "useHoloDebug", from: resolver.resolve("./runtime/composables") },
-        { name: "useStorage", as: "useStorage", from: resolver.resolve("./runtime/composables") },
-        { name: "Storage", as: "Storage", from: resolver.resolve("./runtime/composables") }
-      ]);
+        { name: "useHoloDebug", as: "useHoloDebug", from: resolver.resolve("./runtime/composables") }
+      ];
+      if (storageModule) {
+        imports.push(
+          { name: "useStorage", as: "useStorage", from: resolver.resolve("./runtime/composables/storage") },
+          { name: "Storage", as: "Storage", from: resolver.resolve("./runtime/composables/storage") }
+        );
+      }
+      addServerPlugin(resolver.resolve("./runtime/plugins/init"));
+      addImports(imports);
       addServerImportsDir(resolver.resolve("./runtime/server/imports"));
-      addServerImportsDir(resolve(sourceDir, "server/models"));
+      const serverModelImports = await createServerModelImports(sourceDir);
+      if (serverModelImports) {
+        addServerImportsDir(serverModelImports);
+      }
       opts._holoCoreRuntimeRegistered = true;
     }
-    if (!opts._holoStorageRuntimeRegistered) {
+    if (storageModule && !opts._holoStorageRuntimeRegistered) {
       addServerPlugin(resolver.resolve("./runtime/plugins/storage"));
       opts._holoStorageRuntimeRegistered = true;
     }
-    if (!opts.nitro.storage || Object.keys(opts.nitro.storage).every((key) => !key.startsWith("holo:"))) {
-      applyNitroStorageConfig(opts, normalizedStorage, s3Driver);
+    if (storageModule && normalizedStorage && (!opts.nitro.storage || Object.keys(opts.nitro.storage).every((key) => !key.startsWith("holo:")))) {
+      storageModule.applyNitroStorageConfig(opts, normalizedStorage, s3Driver);
     }
     const runtimePath = resolver.resolve("./runtime");
     if (!opts.build.transpile.includes(runtimePath)) {
       opts.build.transpile.push(runtimePath);
     }
-    if (!opts._holoStorageFinalizeRegistered) {
+    if (storageModule && !opts._holoStorageFinalizeRegistered) {
       opts._holoStorageFinalizeRegistered = true;
       nuxt.hook("modules:done", () => {
-        const finalNormalized = normalizeModuleOptions(opts._holoStorageModuleOptions);
+        const finalNormalized = storageModule.normalizeModuleOptions(opts._holoStorageModuleOptions);
         opts.runtimeConfig = opts.runtimeConfig || {};
         opts.runtimeConfig.holoStorage = finalNormalized;
-        applyNitroStorageConfig(opts, finalNormalized, s3Driver);
-        if (hasPublicLocalDisk(finalNormalized)) {
+        storageModule.applyNitroStorageConfig(opts, finalNormalized, s3Driver);
+        if (storageModule.hasPublicLocalDisk(finalNormalized)) {
           addServerHandler({
             route: `${finalNormalized.routePrefix}/**`,
             handler: resolver.resolve("./runtime/server/routes/storage.get")
@@ -88,8 +185,13 @@ const module$1 = defineNuxtModule({
     }
   }
 });
+const moduleInternals = {
+  hasModuleNotFoundCode,
+  hasLoadedConfigFile,
+  importOptionalStorageS3Module
+};
 const adapterNuxtInternals = {
   toStorageModuleOptions
 };
 
-export { adapterNuxtInternals, module$1 as default };
+export { adapterNuxtInternals, module$1 as default, moduleInternals };

package/dist/runtime/composables/index.d.ts

@@ -1,16 +1,3 @@
-export {
-  Storage,
-  configureStorageRuntime,
-  resetStorageRuntime,
-  useStorage,
-  type StorageBackend,
-  type StorageContent,
-  type StorageDisk,
-  type StorageInstance,
-  type StorageRuntimeBindings,
-  type TemporaryUrlOptions,
-} from '@holo-js/storage/runtime'
-
 export interface HoloRuntimeConnection {
   driver?: 'sqlite' | 'postgres' | 'mysql'
   url?: string

package/dist/runtime/composables/index.js

@@ -1,9 +1,3 @@
-export {
-  Storage,
-  configureStorageRuntime,
-  resetStorageRuntime,
-  useStorage
-} from "@holo-js/storage/runtime";
 import {
   createHoloProjectAccessors,
   initializeHoloAdapterProject

package/dist/runtime/composables/storage.d.ts

@@ -0,0 +1,12 @@
+export {
+  Storage,
+  configureStorageRuntime,
+  resetStorageRuntime,
+  useStorage,
+  type StorageBackend,
+  type StorageContent,
+  type StorageDisk,
+  type StorageInstance,
+  type StorageRuntimeBindings,
+  type TemporaryUrlOptions,
+} from '@holo-js/storage/runtime'

package/dist/runtime/composables/storage.js

@@ -0,0 +1,6 @@
+export {
+  Storage,
+  configureStorageRuntime,
+  resetStorageRuntime,
+  useStorage
+} from "@holo-js/storage/runtime";

package/dist/runtime/drivers/s3.js

@@ -1 +1 @@
-export { default } from "@holo-js/storage/runtime/drivers/s3";
+export { default } from "@holo-js/storage-s3";

package/dist/runtime/plugins/init.js

@@ -2,6 +2,8 @@ import {
   configureHoloRuntimeConfig
 } from "../composables/index.js";
 import { initializeHoloAdapterProject } from "@holo-js/core";
+import { useRuntimeConfig } from "nitropack/runtime/config";
+import { defineNitroPlugin } from "nitropack/runtime/plugin";
 export default defineNitroPlugin(async (nitroApp) => {
   const config = useRuntimeConfig();
   configureHoloRuntimeConfig(config);

package/dist/runtime/plugins/storage.js

@@ -1,5 +1,7 @@
 import { configureStorageRuntime } from "@holo-js/storage/runtime";
-import { useRuntimeConfig, useStorage as useNitroStorage } from "#imports";
+import { useRuntimeConfig } from "nitropack/runtime/config";
+import { defineNitroPlugin } from "nitropack/runtime/plugin";
+import { useStorage as useNitroStorage } from "nitropack/runtime/storage";
 export default defineNitroPlugin(() => {
   configureStorageRuntime({
     getRuntimeConfig: () => useRuntimeConfig(),

package/dist/runtime/shims.d.ts

@@ -43,6 +43,18 @@ declare module '#imports' {
   export function useStorage(base: string): unknown
 }
 
+declare module 'nitropack/runtime/config' {
+  export function useRuntimeConfig(): HoloRuntimeConfig
+}
+
+declare module 'nitropack/runtime/plugin' {
+  export function defineNitroPlugin<T>(plugin: T): T
+}
+
+declare module 'nitropack/runtime/storage' {
+  export function useStorage(base: string): unknown
+}
+
 declare global {
   function createError(input: { statusCode: number, statusMessage: string }): Error
   function defineNitroPlugin<T>(plugin: T): T

package/dist/types.d.mts

@@ -1,3 +1,3 @@
-export { type adapterNuxtInternals, default } from './module.mjs'
+export { type adapterNuxtInternals, default, type moduleInternals } from './module.mjs'
 
 export { type ModuleOptions } from './module.mjs'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holo-js/adapter-nuxt",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Holo-JS Framework - Nuxt adapter",
   "type": "module",
   "license": "MIT",
@@ -16,6 +16,10 @@
     "./runtime": {
       "types": "./dist/runtime/composables/index.d.ts",
       "import": "./dist/runtime/composables/index.js"
+    },
+    "./storage": {
+      "types": "./dist/runtime/composables/storage.d.ts",
+      "import": "./dist/runtime/composables/storage.js"
     }
   },
   "main": "./dist/module.mjs",
@@ -31,13 +35,28 @@
   },
   "dependencies": {
     "@nuxt/kit": "^4.0.0",
-    "@holo-js/config": "^0.1.2",
-    "@holo-js/core": "^0.1.2",
-    "@holo-js/db": "^0.1.2",
-    "@holo-js/forms": "^0.1.2",
-    "@holo-js/storage": "^0.1.2"
+    "@holo-js/config": "^0.1.4",
+    "@holo-js/core": "^0.1.4",
+    "@holo-js/db": "^0.1.4"
+  },
+  "peerDependencies": {
+    "@holo-js/forms": "^0.1.4",
+    "@holo-js/storage": "^0.1.4",
+    "@holo-js/storage-s3": "^0.1.4"
+  },
+  "peerDependenciesMeta": {
+    "@holo-js/forms": {
+      "optional": true
+    },
+    "@holo-js/storage": {
+      "optional": true
+    },
+    "@holo-js/storage-s3": {
+      "optional": true
+    }
   },
   "devDependencies": {
+    "@holo-js/storage-s3": "workspace:*",
     "@nuxt/module-builder": "^1.0.2",
     "@types/node": "^22.10.2",
     "nuxt": "^4.0.0",