@seedprotocol/sdk 0.4.2 → 0.4.3

package/dist/node/helpers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/node/helpers/index.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,WAAW,GAAU,CAAC,EAAE,UAAU,MAAM,KAAG,OAAO,CAAC,CAAC,CAuDhE,CAAA;AAED,eAAO,MAAM,wBAAwB,GACnC,KAAK,MAAM,EACX,WAAW,MAAM,kBAgBlB,CAAA"}

package/dist/node/helpers/scripts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scripts.d.ts","sourceRoot":"","sources":["../../../src/node/helpers/scripts.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,KAAG,OAO/C,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc,QAAO,MAAM,GAAG,IAqB1C,CAAA;AAyFD;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,GACtB,gBAAgB,MAAM,EACtB,kBAAkB,MAAM,KACvB,OAAO,CAAC,IAAI,CA8Ed,CAAA"}

package/dist/node/index.d.ts

@@ -0,0 +1,24 @@
+export { Model, Property, Image, List, Text, Json, Relation, Boolean, Number, Date, } from '../Schema';
+export { Item } from '../Item/Item';
+export { ItemProperty } from '../ItemProperty/ItemProperty';
+export { FileManager } from './helpers/FileManager';
+export { Db } from './db/Db';
+export { models, versions, seeds, metadata, appState, config, modelUids } from '../seedSchema';
+export { getCorrectId } from '../helpers';
+export * from '../imports';
+export { eventEmitter } from '../eventBus';
+export { withSeed } from './webpack';
+export { client } from '../client';
+export * from '../types';
+export { PathResolver } from './helpers/PathResolver';
+export { BasePathResolver } from '../helpers/PathResolver/BasePathResolver';
+export { getTsImport } from './helpers';
+export { commandExists, runSeedInit, findSeedBinary } from './helpers/scripts';
+export { INIT_SCRIPT_SUCCESS_MESSAGE, SCHEMA_TS } from '../helpers/constants';
+export { createDrizzleSchemaFilesFromConfig, generateModelCode } from './codegen/drizzle';
+import './helpers/EasClient';
+import './helpers/QueryClient';
+import './helpers/FileManager';
+import './helpers/ArweaveClient';
+import './helpers/PathResolver';
+//# sourceMappingURL=index.d.ts.map

package/dist/node/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/node/index.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,EACL,QAAQ,EACR,KAAK,EACL,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,QAAQ,EACR,OAAO,EACP,MAAM,EACN,IAAI,GACL,MAAM,WAAW,CAAA;AAGlB,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AACnC,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAG3D,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAG5B,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAM9F,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAGzC,cAAc,YAAY,CAAA;AAG1B,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAG1C,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAQpC,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AAGlC,cAAc,UAAU,CAAA;AAGxB,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAA;AAC3E,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AACvC,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAC9E,OAAO,EAAE,2BAA2B,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AAE7E,OAAO,EAAE,kCAAkC,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAGzF,OAAO,qBAAqB,CAAA;AAC5B,OAAO,uBAAuB,CAAA;AAC9B,OAAO,uBAAuB,CAAA;AAC9B,OAAO,yBAAyB,CAAA;AAChC,OAAO,wBAAwB,CAAA"}

package/dist/node/seed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed.d.ts","sourceRoot":"","sources":["../../src/node/seed.ts"],"names":[],"mappings":""}

package/dist/node/webpack/fs-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-proxy.d.ts","sourceRoot":"","sources":["../../../src/node/webpack/fs-proxy.js"],"names":[],"mappings":";;eAAe,aAAa"}

package/dist/node/webpack/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/node/webpack/index.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,QAAQ,GAAI,QAAQ,GAAG,EAAE,SAAS,GAAG,EAAE,UAAU,OAAO,QAsGpE,CAAA"}

package/dist/node.js

@@ -1,40 +1,530 @@
 import { enableMapSet } from 'immer';
 import 'reflect-metadata';
-import './Model/index.js';
-export { Boolean, Date, Image, Json, List, Number, Property, Relation, Text } from './helpers/property/index.js';
-import 'pluralize';
-export { seeds } from './seedSchema/SeedSchema.js';
-export { versions } from './seedSchema/VersionSchema.js';
-export { metadata } from './seedSchema/MetadataSchema.js';
-export { appState } from './seedSchema/AppStateSchema.js';
-export { models } from './seedSchema/ModelSchema.js';
-export { modelUids } from './seedSchema/ModelUidSchema.js';
-import './seedSchema/PropertyUidSchema.js';
-export { config } from './seedSchema/ConfigSchema.js';
-import './seedSchema/SchemaSchema.js';
-import './seedSchema/ModelSchemaSchema.js';
+import { a as ModelPropertyDataTypes, P as Property, a2 as addModelsToDb, v as BasePathResolver, o as modelPropertiesToObject, a3 as SCHEMA_NJK } from './json-I3vJhXo8.js';
+export { B as Boolean, D as Date, a7 as INIT_SCRIPT_SUCCESS_MESSAGE, I as Image, a0 as Item, a4 as ItemProperty, J as Json, L as List, M as Model, N as Number, R as Relation, a8 as SCHEMA_TS, g as Text, u as appState, a6 as client, A as config, a5 as eventEmitter, j as getCorrectId, a9 as importJsonSchema, aa as loadSchemaFromFile, C as metadata, H as modelUids, q as models, ab as readJsonImportFile, X as seeds, ac as transformImportToSchemaFile, Y as versions } from './json-I3vJhXo8.js';
+import pluralize from 'pluralize';
 import 'drizzle-orm';
-import './Schema/validation.js';
-export { Item } from './Item/Item.js';
-export { ItemProperty } from './ItemProperty/ItemProperty.js';
-export { FileManager } from './node/helpers/FileManager.js';
-export { Db } from './node/db/Db.js';
-export { getCorrectId } from './helpers/index.js';
-export { parseMarkdownFrontmatter, processSeedConfig, saveModelsFromMarkdown } from './imports/markdown.js';
-export { importJsonSchema, loadSchemaFromFile, readJsonImportFile, transformImportToSchemaFile } from './imports/json.js';
-export { eventEmitter } from './eventBus.js';
-export { withSeed } from './node/webpack/index.js';
-export { ClientManager as client } from './client/ClientManager.js';
-export { PathResolver } from './node/helpers/PathResolver.js';
-export { BasePathResolver } from './helpers/PathResolver/BasePathResolver.js';
-export { getTsImport } from './node/helpers/index.js';
-export { commandExists, findSeedBinary, runSeedInit } from './node/helpers/scripts.js';
-export { INIT_SCRIPT_SUCCESS_MESSAGE, SCHEMA_TS } from './helpers/constants.js';
-export { createDrizzleSchemaFilesFromConfig, generateModelCode } from './node/codegen/drizzle.js';
-import './node/helpers/EasClient.js';
-import './node/helpers/QueryClient.js';
-import './node/helpers/ArweaveClient.js';
-export { Model } from './Model/Model.js';
+export { FileManager } from './FileManager-Ct91ZhOE.js';
+export { Db } from './Db-BPnO1-_p.js';
+import yaml from 'js-yaml';
+import fs__default, { readFileSync } from 'fs';
+export { PathResolver } from './PathResolver-BErmcZqP.js';
+import * as tsImport from 'ts-import';
+import { LoadMode } from 'ts-import';
+import path from 'path';
+import 'glob';
+import 'rimraf';
+import debug from 'debug';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { drizzle } from 'drizzle-orm/libsql';
+import { pushSQLiteSchema } from 'drizzle-kit/api';
+import { s as schema } from './index-r45w9hEq.js';
+import { createClient } from '@libsql/client';
+import { camelCase, snakeCase } from 'lodash-es';
+import './EasClient-BwhUcPjY.js';
+import './QueryClient-D2mv63gP.js';
+import './ArweaveClient-BvJ1FhQ5.js';
+import 'xstate';
+import 'rxjs';
+import 'drizzle-orm/casing';
+import '@sinclair/typebox';
+import 'arweave';
+import 'eventemitter3';
+import 'drizzle-orm/sqlite-core';
+import 'ethers';
+import 'nanoid';
+import 'nanoid-dictionary';
+import 'fs/promises';
+import 'graphql-request';
+import './queries-LZYSuhtz.js';
+
+/**
+ * Parses markdown frontmatter from a file
+ * @param filePath Path to the markdown file
+ * @returns The parsed frontmatter as an object, or null if no frontmatter found
+ */
+const parseMarkdownFrontmatter = (filePath) => {
+    const content = readFileSync(filePath, 'utf-8');
+    // Check for frontmatter delimiters (more flexible regex)
+    // Matches --- at start, optional whitespace, content, ---, optional whitespace
+    const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---(\s*\n|$)/;
+    const match = content.match(frontmatterRegex);
+    if (!match) {
+        return null;
+    }
+    const frontmatterYaml = match[1];
+    try {
+        const frontmatter = yaml.load(frontmatterYaml);
+        return frontmatter;
+    }
+    catch (error) {
+        throw new Error(`Failed to parse YAML frontmatter in ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+/**
+ * Converts a seed config from frontmatter to ModelDefinitions format
+ * @param config The seed configuration from frontmatter
+ * @returns ModelDefinitions object ready to be saved to database
+ */
+const processSeedConfig = (config) => {
+    if (!config.seed) {
+        throw new Error('No seed configuration found in frontmatter');
+    }
+    const { model: modelName, properties: propertiesConfig } = config.seed;
+    if (!modelName) {
+        throw new Error('Model name is required in seed configuration');
+    }
+    if (!propertiesConfig || Object.keys(propertiesConfig).length === 0) {
+        throw new Error('Properties are required in seed configuration');
+    }
+    // Convert property configs to Property definitions
+    const schema = {};
+    for (const [propertyName, propertyConfig] of Object.entries(propertiesConfig)) {
+        const { type, target } = propertyConfig;
+        if (!type) {
+            throw new Error(`Property type is required for ${propertyName}`);
+        }
+        // Map the type to Property constructor
+        switch (type) {
+            case ModelPropertyDataTypes.Text:
+                schema[propertyName] = Property.Text();
+                break;
+            case ModelPropertyDataTypes.Number:
+                schema[propertyName] = Property.Number();
+                break;
+            case ModelPropertyDataTypes.Boolean:
+                schema[propertyName] = Property.Boolean();
+                break;
+            case ModelPropertyDataTypes.Date:
+                schema[propertyName] = Property.Date();
+                break;
+            case ModelPropertyDataTypes.Image:
+                schema[propertyName] = Property.Image();
+                break;
+            case ModelPropertyDataTypes.Json:
+                schema[propertyName] = Property.Json();
+                break;
+            case ModelPropertyDataTypes.File:
+                schema[propertyName] = Property.File();
+                break;
+            case ModelPropertyDataTypes.Relation:
+                if (!target) {
+                    throw new Error(`Target model is required for Relation property ${propertyName}`);
+                }
+                schema[propertyName] = Property.Relation(target);
+                break;
+            case ModelPropertyDataTypes.List:
+                if (!target) {
+                    throw new Error(`Target model is required for List property ${propertyName}`);
+                }
+                schema[propertyName] = Property.List(target);
+                break;
+            default:
+                throw new Error(`Unknown property type: ${type} for property ${propertyName}`);
+        }
+    }
+    // Create a mock ModelClass structure that matches ModelDefinitions
+    // This is a simplified version that works with addModelsToInternalDb
+    const modelClass = {
+        schema,
+        create: async () => {
+            throw new Error('Model.create() should not be called directly');
+        },
+        originalConstructor: class {
+        },
+    };
+    return {
+        [modelName]: modelClass,
+    };
+};
+/**
+ * Reads a markdown file, parses frontmatter, and saves models/properties to database
+ * @param filePath Path to the markdown file
+ * @param db Database instance (BetterSQLite3Database or SqliteRemoteDatabase)
+ * @returns The created ModelDefinitions
+ */
+const saveModelsFromMarkdown = async (filePath, db) => {
+    // Parse frontmatter
+    const frontmatter = parseMarkdownFrontmatter(filePath);
+    if (!frontmatter) {
+        throw new Error(`No frontmatter found in ${filePath}`);
+    }
+    // Validate and process seed config
+    const seedConfig = frontmatter;
+    const modelDefinitions = processSeedConfig(seedConfig);
+    // Save to database
+    await addModelsToDb(modelDefinitions, undefined, undefined, undefined);
+    return modelDefinitions;
+};
+
+// import path from "path";
+// import { fileURLToPath } from "url";
+// const __filename = fileURLToPath(import.meta.url);
+// const __dirname = path.dirname(__filename);
+const withSeed = (config, webpack, isServer) => {
+    // If you need to include directories outside of the project root
+    // config.module.rules.push({
+    //   test: /\.ts$/,
+    //   include: [path.resolve(process.cwd(), 'schema.ts')],
+    //   use: 'ts-loader',
+    // })
+    config.plugins.push(
+    // new webpack.DefinePlugin({
+    //   __dirname: JSON.stringify(__dirname),
+    // }),
+    new webpack.NormalModuleReplacementPlugin(/node:/, (resource) => {
+        resource.request = resource.request.replace(/^node:/, '');
+    }));
+    // config.externals.push({
+    //   'fsevents': 'commonjs2 fsevents',
+    // })
+    // console.log('__dirname:', __dirname)
+    // console.log('process.cwd():', process.cwd())
+    // console.log('crypto-browserify exists:', fs.existsSync(path.resolve(process.cwd(), './node_modules/crypto-browserify')))
+    // console.log('path-browserify exists:', fs.existsSync(path.resolve(process.cwd(), './node_modules/path-browserify')))
+    if (!isServer) {
+        // config.plugins.push(
+        //   new webpack.NormalModuleReplacementPlugin(/node:/, (resource: any) => {
+        //     resource.request = resource.request.replace(/^node:/, '')
+        //   }),
+        // )
+        // config.plugins.push(
+        //   new webpack.NormalModuleReplacementPlugin(
+        //     /^(node:)?fs$/,
+        //     (resource: any) => {
+        //       resource.request = '@zenfs/core';
+        //     }
+        //   )
+        // )
+        // config.module.rules.push({
+        //   test: /\.js$/,
+        //   exclude: '/node_modules/@seedprotocol/sdk/node', // Exclude the 'node-files' directory
+        //   use: {
+        //     loader: 'babel-loader',
+        //     options: {
+        //       presets: ['next/babel'],
+        //     },
+        //   },
+        // });
+        // config.resolve.alias['fs/promises'] = '@zenfs/core/promises';
+        config.resolve.alias['fs'] = '@zenfs/core';
+        config.resolve.alias['node:fs'] = '@zenfs/core';
+        config.resolve.alias['node:path'] = 'path-browserify';
+        config.resolve.alias['path'] = 'path-browserify';
+        // config.resolve.alias['fs'] = path.resolve(
+        //   process.cwd(),
+        //   './node_modules/@zenfs/core',
+        // )
+        // config.resolve.alias['node:fs'] = path.resolve(
+        //   process.cwd(),
+        //   './node_modules/@zenfs/core',
+        // )
+        // config.resolve.alias['@schema'] = path.resolve(process.cwd(), 'schema.ts')
+        // // config.resolve.alias['crypto']      = path.resolve(process.cwd(), './node_modules/crypto-browserify')
+        // // config.resolve.alias['node:crypto'] = path.resolve(process.cwd(), './node_modules/crypto-browserify')
+        // config.resolve.alias['node:path'] = path.resolve(
+        //   process.cwd(),
+        //   './node_modules/path-browserify',
+        // )
+        // config.resolve.alias['path'] = path.resolve(
+        //   process.cwd(),
+        //   './node_modules/path-browserify',
+        // )
+    }
+    if (isServer) {
+        config.externals.push('@sqlite.org/sqlite-wasm');
+        config.externals.push('nunjucks');
+        config.externals.push('chokidar');
+        config.externals.push('arweave');
+    }
+    // config.module.rules.push({
+    //   test: /seed\.config\.mjs$/,
+    //     use: [
+    //       {
+    //         loader: 'babel-loader',
+    //         options: {
+    //           plugins: ['@babel/plugin-syntax-dynamic-import'],
+    //         },
+    //       },
+    //     ],
+    // })
+    return config;
+};
+
+const logger$1 = debug('seedSdk:helpers');
+const getTsImport = async (filePath) => {
+    // Check if the config file exists
+    if (!fs__default.existsSync(filePath)) {
+        logger$1(`Typescript file not found at ${filePath}`);
+        throw new Error(`Typescript file not found at ${filePath}`);
+    }
+    let result;
+    try {
+        // Read the file content and transform relative imports to absolute paths
+        // This fixes the issue where ts-import compiles to .mjs in cache and relative
+        // imports resolve from the cache location instead of the original file location
+        let fileContent = fs__default.readFileSync(filePath, 'utf-8');
+        const fileDir = path.dirname(path.resolve(filePath));
+        // Replace relative imports with absolute paths
+        // Match: from '../../../../src/schema' or from '../../../something'
+        const relativeImportRegex = /from\s+['"](\.\.\/.*?)['"]/g;
+        fileContent = fileContent.replace(relativeImportRegex, (match, importPath) => {
+            const absolutePath = path.resolve(fileDir, importPath);
+            // Convert to file:// URL for ESM compatibility, or use absolute path
+            return `from '${absolutePath}'`;
+        });
+        // Write to a temporary file and load that instead
+        const tempFile = path.join(fileDir, `.temp.${path.basename(filePath)}`);
+        fs__default.writeFileSync(tempFile, fileContent);
+        try {
+            result = await tsImport.load(tempFile, {
+                mode: LoadMode.Compile,
+                compileOptions: {
+                    compilerOptions: {
+                        experimentalDecorators: true,
+                        emitDecoratorMetadata: true,
+                    },
+                },
+            }).catch((e) => {
+                logger$1('Error loading ts file:', e);
+                throw e;
+            });
+        }
+        finally {
+            // Clean up temp file
+            if (fs__default.existsSync(tempFile)) {
+                fs__default.unlinkSync(tempFile);
+            }
+        }
+    }
+    catch (e) {
+        console.error(e);
+    }
+    return result;
+};
+
+// Get the directory of this file to resolve relative paths
+// @ts-ignore - rollup plugin-typescript doesn't recognize import.meta with module: "preserve"
+const __filename$1 = fileURLToPath(import.meta.url);
+path.dirname(__filename$1);
+const commandExists = (command) => {
+    try {
+        execSync(`which ${command}`, { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Finds the seed binary path, trying multiple locations
+ * @returns The path to the seed binary, or null if not found
+ */
+const findSeedBinary = () => {
+    const cwd = process.cwd();
+    // Try common locations for the seed binary
+    const possiblePaths = [
+        path.join(cwd, 'node_modules', '.bin', 'seed'),
+        path.join(cwd, 'node_modules', '@seedprotocol', 'cli', 'dist', 'bin.js'),
+        // Try parent directories (for monorepos or nested projects)
+        path.join(cwd, '..', 'node_modules', '.bin', 'seed'),
+        path.join(cwd, '..', 'node_modules', '@seedprotocol', 'cli', 'dist', 'bin.js'),
+        path.join(cwd, '..', '..', 'node_modules', '.bin', 'seed'),
+        path.join(cwd, '..', '..', 'node_modules', '@seedprotocol', 'cli', 'dist', 'bin.js'),
+    ];
+    for (const binPath of possiblePaths) {
+        if (fs__default.existsSync(binPath)) {
+            return binPath;
+        }
+    }
+    return null;
+};
+/**
+ * Runs seed init programmatically, trying multiple methods:
+ * 1. Try to dynamically import and call the CLI package's init function (prefers local monorepo version)
+ * 2. Try to find and execute the seed binary
+ * 3. Fall back to using npx
+ * @param schemaFileDir - Optional path to schema file directory
+ * @param appFilesDirPath - Optional path to app files directory
+ */
+const runSeedInit = async (schemaFileDir, appFilesDirPath) => {
+    const dbDirExists = fs__default.existsSync(`${appFilesDirPath}/db`);
+    if (!dbDirExists) {
+        fs__default.mkdirSync(`${appFilesDirPath}/db`, { recursive: true });
+    }
+    const dbUrl = `file:${appFilesDirPath}/db/seed.db`;
+    const client = createClient({ url: dbUrl });
+    const db = drizzle(client, { schema });
+    const { apply, hasDataLoss, warnings, statementsToExecute } = await pushSQLiteSchema(schema, db);
+    // You can inspect what will happen before applying
+    await apply();
+    // // First, try to dynamically import the CLI package's init function
+    // // This prefers local monorepo version in development, falls back to published package
+    // try {
+    //   const cliModule = await importCliPackage()
+    //   if (cliModule && typeof cliModule.init === 'function') {
+    //     await cliModule.init(schemaFileDir, appFilesDirPath)
+    //     return
+    //   }
+    // } catch (importError: any) {
+    //   // CLI package not available, continue to other methods
+    //   console.log('[seedInit] CLI package not available, trying binary execution')
+    // }
+    // // Try to find and execute the binary
+    // const seedBinary = findSeedBinary()
+    // if (seedBinary) {
+    //   // Binary found, execute it directly
+    //   const args = ['init']
+    //   if (schemaFileDir) {
+    //     args.push(schemaFileDir)
+    //   }
+    //   if (appFilesDirPath) {
+    //     args.push(appFilesDirPath)
+    //   }
+    //   try {
+    //     execSync(`node "${seedBinary}" ${args.join(' ')}`, {
+    //       stdio: 'inherit',
+    //       cwd: process.cwd(),
+    //     })
+    //     return
+    //   } catch (error: any) {
+    //     console.warn(`[seedInit] Failed to execute binary at ${seedBinary}: ${error.message}`)
+    //     // Continue to npx fallback
+    //   }
+    // }
+    // // Final fallback: use npx
+    // const args = ['seed', 'init']
+    // if (schemaFileDir) {
+    //   args.push(schemaFileDir)
+    // }
+    // if (appFilesDirPath) {
+    //   args.push(appFilesDirPath)
+    // }
+    // try {
+    //   execSync(`npx ${args.join(' ')}`, {
+    //     stdio: 'inherit',
+    //     cwd: process.cwd(),
+    //   })
+    // } catch (error: any) {
+    //   throw new Error(
+    //     `Failed to run seed init command. ` +
+    //     `Tried: CLI package import, binary execution, and npx. ` +
+    //     `Please ensure @seedprotocol/cli is installed: ${error.message}`
+    //   )
+    // }
+};
+
+const logger = debug('seedSdk:codegen:drizzle');
+// Lazy load nunjucks to avoid bundling issues when only PathResolver is used
+let nunjucksEnv = null;
+const getNunjucksEnv = async () => {
+    if (!nunjucksEnv) {
+        const nunjucks = await import('nunjucks');
+        const TemplateLoader = {
+            getSource: (name) => {
+                const pathResolver = BasePathResolver.getInstance();
+                const { templatePath } = pathResolver.getAppPaths();
+                let templateFilePath = templatePath;
+                if (name.includes(templatePath)) {
+                    templateFilePath = name;
+                }
+                else {
+                    templateFilePath = path.join(templatePath, path.basename(name));
+                }
+                const src = fs__default.readFileSync(templateFilePath, 'utf-8');
+                return {
+                    path: name,
+                    src,
+                    noCache: false,
+                };
+            },
+        };
+        // Configure Nunjucks
+        nunjucksEnv = new nunjucks.Environment(TemplateLoader);
+        nunjucksEnv.addFilter('camelCase', camelCase);
+        nunjucksEnv.addFilter('snakeCase', snakeCase);
+        nunjucksEnv.addFilter('pluralize', pluralize);
+    }
+    return nunjucksEnv;
+};
+const refNamesToExcludeFromRelations = [
+    ModelPropertyDataTypes.Text,
+    ModelPropertyDataTypes.Number,
+    ModelPropertyDataTypes.Boolean,
+    ModelPropertyDataTypes.Date,
+];
+const generateDrizzleSchemaCode = async (modelName, model) => {
+    const properties = model.properties || [];
+    if (properties.length === 0) {
+        throw new Error(`Model ${modelName} has no properties`);
+    }
+    const schema = modelPropertiesToObject(properties);
+    const listProperties = Object.entries(schema).filter(([key, propertyDef]) => propertyDef?.dataType === ModelPropertyDataTypes.List && !refNamesToExcludeFromRelations.includes(propertyDef?.ref));
+    const pathResolver = BasePathResolver.getInstance();
+    const { templatePath } = pathResolver.getAppPaths();
+    const filePath = path.join(templatePath, SCHEMA_NJK);
+    const env = await getNunjucksEnv();
+    const schemaCode = env.render(filePath, {
+        modelName,
+        modelClass: model, // Keep modelClass name for template compatibility
+        listProperties,
+    });
+    return schemaCode;
+};
+const createDrizzleSchemaFilesFromConfig = async (configFilePath, outputDirPath) => {
+    const pathResolver = BasePathResolver.getInstance();
+    const { dotSeedDir, appSchemaDir } = pathResolver.getAppPaths();
+    // Use provided config file path or find the config file in the project root
+    const schemaFilePath = configFilePath || pathResolver.findConfigFile() || path.join(dotSeedDir, 'seed.config.ts');
+    const { models, } = await getTsImport(schemaFilePath);
+    const writeToDir = outputDirPath || appSchemaDir;
+    for (const [modelName, modelClass] of Object.entries(models)) {
+        const code = await generateDrizzleSchemaCode(modelName, modelClass);
+        if (!fs__default.existsSync(writeToDir)) {
+            fs__default.mkdirSync(writeToDir);
+        }
+        const filePath = path.join(writeToDir, `${modelName}Schema.ts`);
+        await fs__default.promises.writeFile(filePath, code).catch((e) => console.error(e));
+    }
+};
+// Helper to determine TypeScript type based on property type
+const seedTypeToJsType = (propertyType) => {
+    switch (propertyType) {
+        case ModelPropertyDataTypes.Text:
+            return 'string';
+        case ModelPropertyDataTypes.Number:
+            return 'number';
+        case ModelPropertyDataTypes.Boolean:
+            return 'boolean';
+        case ModelPropertyDataTypes.Date:
+            return 'string';
+        case ModelPropertyDataTypes.List:
+            return 'string[]';
+        case ModelPropertyDataTypes.Relation:
+            return 'string';
+        case ModelPropertyDataTypes.Image:
+            return 'string';
+        case ModelPropertyDataTypes.File:
+            return 'string';
+        default:
+            return 'any';
+    }
+};
+const generateModelCode = async (values) => {
+    const { modelName, properties } = values;
+    const pathResolver = BasePathResolver.getInstance();
+    const { templatePath } = pathResolver.getAppPaths();
+    if (modelName === ModelPropertyDataTypes.Text || modelName === 'TestModel') {
+        logger(`Model name is ${modelName}.`);
+    }
+    const nunjucks = await import('nunjucks');
+    const njkEnv = new nunjucks.Environment(new nunjucks.FileSystemLoader(templatePath));
+    njkEnv.addFilter('seedTypeToJsType', seedTypeToJsType);
+    return njkEnv.render('model.njk', { modelName, properties });
+};
 
 enableMapSet();
+
+export { BasePathResolver, Property, commandExists, createDrizzleSchemaFilesFromConfig, findSeedBinary, generateModelCode, getTsImport, parseMarkdownFrontmatter, processSeedConfig, runSeedInit, saveModelsFromMarkdown, withSeed };
 //# sourceMappingURL=node.js.map