@seedprotocol/sdk 0.1.1

package/README.md

@@ -0,0 +1,314 @@
+# [WIP] Seed Protocol SDK
+
+This API is a work in progress. It is not yet ready for production use. These docs are for keeping the community
+informed
+and generating feedback.
+
+## Current research questions
+
+- Can we use TypeORM backed by Sqlite Wasm for more performant and future-proof storage?
+    - Track this research here: [TypeORM Sqlite Wasm](https://github.com/JournoDAO/typeorm-sqlite-wasm)
+- What would the tooling look like to allow export of data model as ProtoBuf and/or JSON Schema?
+    - Looking at [ts-proto](https://github.com/stephenh/ts-proto) for Typescript
+
+## Installing
+
+This package is not yet published to npm, but when it is, this will be the command to install it:
+
+```bash
+yarn add @seedprotocol/sdk
+```
+
+## Getting Started
+
+The first thing to do when integrating Seed SDK is define you data model.
+
+For example, let's pretend we're creating a blog that uses Seed Protocol as its content store. We start by defining
+our `Models`, their `Properties`, and what type of data each `Property` is expecting.
+
+```typescript=
+import {Model, Property, List, createStore} from '@seedprotocol/sdk'
+
+
+const Image = Model({
+      storageTransactionId: Property.String(),
+      uri: Property.String(),
+      alt: Property.String(),
+    },)
+
+const Link = Model({
+  url: Property.String(),
+  text: Property.String(),
+},)
+
+const Identity = Model({
+  name: Property.String(),
+  bio: Property.String(),
+  avatarImage: Image,
+},)
+
+const Post = Model({
+  title: Property.String(),
+  summary: Property.String(),
+  featureImage: Image,
+  html: Property.String(),
+  json: Property.String(),
+  authors: Property.List(Identity,),
+},)
+
+createStore({
+  Identity,
+  Image,
+  Link,
+  Post,
+},)
+```
+
+This will create a database locally in the browser with all the tables and fields necessary to support your Models. Feel
+free to check it out for yourself in your browser's Dev Tools.
+
+Notice that we create relationships by defining a `Property` that takes its related Model as its type. For one-to-many
+relationships, we use the `List` type and pass in the `Model` type we want.
+
+So creating a Post would look like this:
+
+```typescript=
+import {Post, Image, Identity} from './seed/models'
+import html from './index.html'
+
+const image = await Image.create({
+    src: 'https://imgr.com/image.jpg',
+})
+
+const author = await Identity.create({
+    name: 'Keith Axline',
+    profile: 'Developer for Seed Protocol',
+})
+
+const authors = [
+    author
+]
+
+const post = await Post.create({
+    title: 'Some title',
+    summary: 'My summary',
+    featureImage: image,
+    authors,
+})
+
+await post.publish()
+
+// And later when we want to update the post
+post.title = 'Something else'
+
+await post.publish()
+
+```
+
+## Usage
+
+```typescript
+import { SeedFile } from '@seedprotocol/sdk'
+
+const fileFromUrl = new SeedFile('https://example.com/file.txt')
+
+fileFromUrl.subscribe(( event, status ) => {
+  console.log(`Event: ${event}, Status: ${status}`)
+})
+
+await fileFromUrl.save()
+
+```
+
+```typescript
+const fileFromPath = new SeedFile('path/to/file.txt')
+
+const fileFromBlob = new SeedFile(new Blob([ 'Hello, World!' ]))
+
+const fileFromBuffer = new SeedFile(Buffer.from('Hello, World!'))
+
+const fileFromFile = new SeedFile(new File([ 'Hello, World!' ], 'file.txt'))
+
+if ( fileFromPath.isSaved ) {
+  console.log('File is saved to Arweave and EAS')
+}
+```
+
+```typescript
+import { SeedFileSystem } from '@seedprotocol/sdk'
+
+const fs = new SeedFileSystem()
+
+fs.subscribe(( event, status ) => {
+  console.log(`Event: ${event}, Status: ${status}`)
+  if ( event === 'connection.success' && status === 'connected' ) {
+    console.log('Connected to user\'s file system')
+  }
+
+  if ( event === 'connection.error' ) {
+    console.error('Error connecting to user\'s file system', event.error)
+  }
+})
+
+await fs.connect() // User prompted to connect browser wallet
+
+const files = await fs.listFiles('/')
+
+files.forEach(file => {
+  console.log(file.name)
+  console.log(file.size)
+  console.log(file.seedPath) // Each wallet address has a virtual root directory with directories and file system paths
+})
+
+```
+
+```typescript
+
+import { SeedImage } from '@seedprotocol/sdk'
+
+const imgFromUrl = new SeedImage('https://example.com/image.png')
+
+const imgFromDataUrl = new SeedImage('data:image/png;base64,iVB....')
+
+await imgFromUrl.save()
+
+const imgBlob    = imgFromUrl.blob()
+const imgBuffer  = imgFromUrl.buffer()
+const imgDataUrl = imgFromUrl.dataUrl()
+
+```
+
+**Note:** Model instances are called Items in the SDK. This is to avoid confusion with the `Model` function that creates
+the data model.
+
+```mermaid
+---
+Title: Seed Protocol SDK
+---
+%%{
+  init: {
+    'theme': 'base',
+    'themeVariables': {
+      'primaryColor': '#e0f2fe',
+      'primaryTextColor': '#0c4a6e',
+      'primaryBorderColor': '#38bdf8',
+      'lineColor': '#475569',
+      'secondaryColor': '#d9f99d',
+      'tertiaryColor': '#fff',
+      'tertiaryBorderColor': '#7e22ce',
+      'tertiaryTextColor': '#7e22ce',
+      'clusterBkg': '#fff'
+    }
+  }
+}%%
+flowchart TD
+    A{Developer}
+    B{User}
+    C{Seed Dev}
+    N{SDK}
+    Q[App Code]
+    D[(sdk_config_db)]
+    E[(app_db)]
+    L[(seeds_db)]
+    G[Schema/Migration files
+    browser/db/seedSchema]
+H[Schema/Migration files
+.seed/app/schema]
+R[Schema/Migration files
+node/db/sdkSchema]
+
+I[browser.seed.db.config.mjs]
+J[sdk.db.config.mjs]
+K[browser.app.db.config.mjs]
+
+O[files.json
+seed/endpoint/list]
+P[Files
+seed/endpoint/files]
+
+S[$> seed init]
+T[scripts/bin]
+
+subgraph SDK Code
+C--changes Seeds or Versions --> I
+C-- changes Models or Properties --> J
+J-- generates -->R
+I-- generates --> G
+subgraph Package Bundle
+R
+G
+end
+end
+
+
+
+subgraph App Code
+A-- adds Models and Properties --> K
+subgraph SDK
+D
+H
+end
+A-- runs --> S
+S-- calls --> T
+T-- reads--> K
+T-- generates --> D
+T-- generates --> H
+end
+
+subgraph App Server
+H-- served at endpoint --> O
+H-- served at endpoint --> P
+end
+
+
+
+subgraph Browser
+B-- adds data--> Q
+subgraph App
+Q-- calls SDK--> N
+subgraph SDK
+E-- notifies -->N
+N<-- files . json --> O
+N<-- files --> P
+N-- updates -->E
+N-- updates --> L
+
+end
+end
+end
+
+
+```
+
+A[Versions From EAS]
+B[Seeds From EAS]
+C[List of Items]
+D[List of Properties]
+E{Property Machine}
+F{Item Machine}
+G{Items Machine}
+
+```mermaid
+sequenceDiagram
+    Items Service ->>+ EAS: Seeds Request
+    EAS -->>+ Items Service: Seed Attestations
+    loop Each Seed Attestation
+        Items Service ->>+ Items Service: Extract Seed Uid
+    end
+    Note over Items Service: Now we have SeedUid[]
+    Items Service ->>+ EAS: Versions Request w/ SeedUid[]
+    EAS -->>+ Items Service: Version Attestations
+    loop Each SeedUid
+        Items Service ->>+ Items Service: Sort Version Uids DESC
+    end
+    loop Each most recent Version for Seed
+        Items Service ->>+ Item Service: Create Item
+    end
+    Note over Items Service: Now we have VersionUid[] for each SeedUid<br />sorted by `createdAt` DESC
+    Item Service ->>+ EAS: Properties Request w/ VersionUid[]
+    EAS -->>+ Item Service: Properties Attestations
+    loop Each Property Attestation
+        Item Service ->>+ Property Service: Create Property Service
+    end
+    Note over Item Service: Now has all Property Services<br />under this._services
+```

package/dist/bin.js

@@ -0,0 +1,369 @@
+#!/usr/bin/env node
+import { n as __awaiter, D as DB_NAME_SDK_CONFIG, o as models, S as SCHEMA_NJK, p as SCHEMA_TS, q as SDK_DB_CONFIG, r as SEED_DB_CONFIG, A as APP_DB_CONFIG, s as addModelsToInternalDb } from './index-VvchoqaM.js';
+import path from 'path';
+import fs from 'fs';
+import { exec as exec$1 } from 'child_process';
+import { promisify } from 'util';
+import { pathToFileURL } from 'url';
+import process$1 from 'node:process';
+import * as tsImport from 'ts-import';
+import { LoadMode } from 'ts-import';
+import 'glob';
+import * as rimraf from 'rimraf';
+import 'dotenv/config';
+import pluralize from 'pluralize';
+import { camelCase, snakeCase } from 'lodash-es';
+import * as nunjucks from 'nunjucks';
+import Database from 'better-sqlite3';
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+import './seed.schema.config-CJPoGRe1.js';
+import { defineConfig } from 'drizzle-kit';
+import dotenv from 'dotenv';
+import 'reflect-metadata';
+import '@sinclair/typebox';
+import 'xstate';
+import '@zenfs/core';
+import 'drizzle-orm';
+import 'drizzle-orm/sqlite-proxy';
+import 'debug';
+import 'dayjs';
+import 'nanoid';
+import 'nanoid-dictionary';
+import 'drizzle-orm/sqlite-core';
+import 'react';
+import 'eventemitter3';
+import 'rxjs';
+import 'immer';
+import '@statelyai/inspect';
+import '@tanstack/react-query';
+import 'graphql-request';
+import '@tanstack/query-sync-storage-persister';
+import '@tanstack/react-query-persist-client';
+import 'arweave';
+import '@zenfs/dom';
+import 'use-immer';
+import '@xstate/react';
+
+// export const generateId = (): string => {
+//   return customAlphabet(alphanumeric, 10)()
+// }
+const getConfig = (configPath) => __awaiter(void 0, void 0, void 0, function* () {
+    // Check if the config file exists
+    if (!fs.existsSync(configPath)) {
+        // TODO: Maybe prompt the developer to create a config file?
+        console.error(`Config file not found at ${configPath}`);
+        throw new Error(`Config file not found at ${configPath}`);
+    }
+    console.log('Loading config:', configPath);
+    // return {}
+    return yield tsImport.load(configPath, {
+        mode: LoadMode.Compile,
+        compileOptions: {
+            compilerOptions: {
+                experimentalDecorators: true,
+                emitDecoratorMetadata: true,
+            },
+        },
+    });
+});
+
+const currentDir = path.dirname(new URL(import.meta.url).pathname);
+const parentToCheck = path.join(currentDir, '..');
+console.log('parentToCheck:', parentToCheck);
+const isInstalled = path.basename(parentToCheck) === '@seedprotocol';
+let rootWithNodeModules = path.join(currentDir, '..', '..', '..');
+if (!isInstalled) {
+    rootWithNodeModules = path.join(parentToCheck, '..');
+}
+let sdkRootDir = path.join(rootWithNodeModules, 'node_modules', '@seedprotocol', 'sdk');
+if (!isInstalled) {
+    sdkRootDir = path.join(rootWithNodeModules, 'src');
+}
+let dotSeedDir$1 = path.join(rootWithNodeModules, '.seed');
+if (!isInstalled) {
+    dotSeedDir$1 = path.join(process.cwd(), '__tests__', '__mocks__', 'project', '.seed');
+}
+const sdkDir = path.join(dotSeedDir$1, 'sdk');
+const sdkSchemaDir = path.join(sdkDir, 'schema');
+const sdkDbDir = path.join(sdkDir, 'db');
+const sdkDbMetaDir = path.join(sdkDbDir, 'meta');
+path.join(sdkDbMetaDir, '_journal.json');
+const seedDir = path.join(dotSeedDir$1, 'seed');
+const seedSchemaDir = path.join(seedDir, 'schema');
+const seedDbDir = path.join(seedDir, 'db');
+const drizzleKitPath = path.join(rootWithNodeModules, 'node_modules', 'drizzle-kit', 'bin.cjs');
+// App file paths. These are the single source of truth for the SDK user's data model
+const appDir = path.join(dotSeedDir$1, 'app');
+const appSchemaDir = path.join(appDir, 'schema');
+const appDbDir = path.join(appDir, 'db');
+path.join(appDbDir, 'meta');
+const appGeneratedSchemaDir = path.join(appDir, 'schema');
+const templatePath = path.join(sdkRootDir, 'node', 'codegen', 'templates');
+
+const getSdkDb = () => {
+    const sqlite = new Database(path.join(sdkDbDir, `${DB_NAME_SDK_CONFIG}.sqlite3`));
+    return drizzle(sqlite);
+};
+
+dotenv.config();
+let dotSeedDir = path.join(process$1.cwd(), '.seed');
+if (process$1.env.IS_SEED_DEV) {
+    dotSeedDir = path.join(process$1.cwd(), '__tests__', '__mocks__', 'project', '.seed');
+}
+defineConfig({
+    schema: [
+        `${dotSeedDir}/app/schema/*Schema.ts`,
+        `${dotSeedDir}/seed/schema/VersionSchema.ts`,
+        `${dotSeedDir}/seed/schema/SeedSchema.ts`,
+        `${dotSeedDir}/seed/schema/MetadataSchema.ts`,
+    ],
+    dialect: 'sqlite',
+    out: `${dotSeedDir}/app/db`,
+    dbCredentials: {
+        url: `${dotSeedDir}/app/db/app_db.sqlite3`,
+    },
+});
+
+const TemplateLoader = {
+    getSource: (name) => {
+        console.log('name:', name);
+        console.log('templatePath:', templatePath);
+        let templateFilePath;
+        if (name.includes(templatePath)) {
+            templateFilePath = name;
+        }
+        else {
+            templateFilePath = path.join(templatePath, path.basename(name));
+        }
+        const src = fs.readFileSync(templateFilePath, 'utf-8');
+        return {
+            path: name,
+            src,
+            noCache: false,
+        };
+    },
+};
+// Configure Nunjucks
+const env = new nunjucks.Environment(TemplateLoader);
+env.addFilter('camelCase', camelCase);
+env.addFilter('snakeCase', snakeCase);
+env.addFilter('pluralize', pluralize);
+const generateDrizzleSchemaCode = (modelName, modelClass) => {
+    const listProperties = Object.entries(modelClass.schema).filter(([key, propertyDef]) => (propertyDef === null || propertyDef === void 0 ? void 0 : propertyDef.dataType) === 'List');
+    const filePath = path.join(templatePath, SCHEMA_NJK);
+    const schemaCode = env.render(filePath, {
+        modelName,
+        modelClass,
+        listProperties,
+    });
+    return schemaCode;
+};
+const syncDbWithDrizzleSchemaFile = (configPath) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = getSdkDb();
+    const modelRecords = yield db.select().from(models);
+    const indexTemplatePath = path.join(templatePath, 'index.njk');
+    const indexFilePath = path.join(appGeneratedSchemaDir, 'index.ts');
+    const indexFileContent = env.render(indexTemplatePath, {
+        models: modelRecords,
+    });
+    console.log('indexFilePath:', indexFilePath);
+    yield fs.promises
+        .writeFile(indexFilePath, indexFileContent)
+        .catch((e) => console.error(e));
+    console.log('[Seed Protocol] Wrote index file to:', indexFilePath);
+    const { models: models$1 } = yield getConfig(configPath);
+    console.log('models.length:', Object.entries(models$1).length);
+    for (const [modelName, modelClass] of Object.entries(models$1)) {
+        const modelRecord = modelRecords.find(({ name }) => name === modelName);
+        if (!modelRecord) {
+            throw new Error(`Model record not found for ${modelName}`);
+        }
+        const code = generateDrizzleSchemaCode(modelRecord.name, modelClass);
+        if (!fs.existsSync(appGeneratedSchemaDir)) {
+            fs.mkdirSync(appGeneratedSchemaDir);
+        }
+        const filePath = path.join(appGeneratedSchemaDir, `${modelRecord.name.toLowerCase()}Schema.ts`);
+        yield fs.promises.writeFile(filePath, code).catch((e) => console.error(e));
+        console.log(`[Seed Protocol] Wrote schema file for ${modelRecord.name} to ${filePath}`);
+    }
+});
+
+const { rimrafSync } = rimraf;
+const exec = promisify(exec$1);
+let a;
+a = process$1.argv.splice(2);
+// const args = a.split(' ')
+const copyDotSeedFilesToAppFiles = (appFilesDirPath, schemaFilePath) => __awaiter(void 0, void 0, void 0, function* () {
+    console.log('[Seed Protocol] Copying dot seed files to app files');
+    return new Promise((resolve) => {
+        if (!fs.existsSync(path.join(sdkDbDir, `${DB_NAME_SDK_CONFIG}.sqlite3`))) {
+            console.log('[Seed Protocol] Waiting for SDK schema files');
+            setTimeout(() => {
+                console.log('[Seed Protocol] Retrying to copy SDK schema files');
+                return copyDotSeedFilesToAppFiles(appFilesDirPath, schemaFilePath);
+            }, 1000);
+        }
+        else {
+            fs.promises.rm(appFilesDirPath, { recursive: true }).then(() => {
+                console.log(`[Seed Protocol] Removed old app files`);
+                const targetSeedDir = path.join(appFilesDirPath, 'seed');
+                const targetSdkDir = path.join(appFilesDirPath, 'sdk');
+                const targetAppDir = path.join(appFilesDirPath, 'app');
+                const schemaFileDest = path.join(appFilesDirPath, SCHEMA_TS);
+                console.log(`[Seed Protocol] making dir at ${appFilesDirPath}`);
+                fs.mkdirSync(appFilesDirPath, { recursive: true });
+                console.log('[Seed Protocol] copying seed, sdk, and app files');
+                fs.cpSync(seedDir, targetSeedDir, { recursive: true });
+                fs.cpSync(sdkDir, targetSdkDir, { recursive: true });
+                fs.cpSync(appDir, targetAppDir, { recursive: true });
+                console.log('[Seed Protocol] copying schema file');
+                fs.copyFileSync(schemaFilePath, schemaFileDest);
+                console.log('[Seed Protocol] removing sqlite3 files and index.ts files');
+                rimrafSync(`${appFilesDirPath}/**/*.sqlite3`, {
+                    glob: true,
+                });
+                rimrafSync(`${appFilesDirPath}/**/index.ts`, {
+                    glob: true,
+                });
+                resolve();
+            });
+        }
+    });
+});
+const init = (args) => {
+    console.log('args:', args);
+    if (args && args.length && args[0] === 'init') {
+        console.log('[Seed Protocol] Running init script');
+        let appFilesDirPath = args[2] || undefined;
+        let pathToConfigFiles = args[1] || rootWithNodeModules;
+        const schemaFilePath = path.join(pathToConfigFiles, SCHEMA_TS);
+        // Remove dotSeedDir to start fresh each time
+        if (fs.existsSync(dotSeedDir$1)) {
+            fs.rmSync(dotSeedDir$1, { recursive: true });
+        }
+        const configDir = path.join(sdkRootDir, 'shared', 'configs');
+        console.log('rootWithNodeModules:', rootWithNodeModules);
+        // The DB config files defined by the SDK, not contained in .seed
+        const sdkDbConfigPath = path.join(configDir, SDK_DB_CONFIG);
+        const drizzleKitCommand = `npx --yes tsx ${drizzleKitPath}`;
+        // SeedDb is where the Seed/Version data model is stored. Then it's exported to the browser for the user
+        const seedDbConfigPath = path.join(configDir, SEED_DB_CONFIG);
+        const seedDbMeta = path.join(dotSeedDir$1, 'seed', 'meta');
+        const appDbConfigPath = path.join(configDir, APP_DB_CONFIG);
+        const browserAppDbMeta = path.join(appDbDir, 'meta');
+        const ensureDirectories = () => {
+            try {
+                fs.mkdirSync(sdkDbDir, { recursive: true }); // Creates .seed/sdk/db
+                fs.mkdirSync(sdkSchemaDir, { recursive: true }); // Creates .seed/sdk/schema
+                fs.mkdirSync(appDbDir, { recursive: true }); // Creates .seed/app/db
+                fs.mkdirSync(appSchemaDir, { recursive: true }); // Creates .seed/app/schema
+                fs.mkdirSync(seedDbDir, { recursive: true }); // Creates .seed/seed/db
+                fs.mkdirSync(seedSchemaDir, { recursive: true }); // Creates .seed/seed/schema
+                fs.mkdirSync(appGeneratedSchemaDir, { recursive: true }); // Creates .seed/app/schema
+                if (appFilesDirPath) {
+                    fs.mkdirSync(appFilesDirPath, { recursive: true });
+                }
+            }
+            catch (error) {
+                console.error('Failed to ensure directories:', error);
+                throw error;
+            }
+        };
+        const copyFiles = (srcDir, destName) => {
+            const destDir = path.join(dotSeedDir$1, destName);
+            const destSchemaDir = path.join(destDir, 'schema');
+            if (!fs.existsSync(destDir)) {
+                fs.mkdirSync(destDir, { recursive: true });
+            }
+            const schemaFiles = fs.readdirSync(srcDir);
+            schemaFiles.forEach((file) => {
+                console.log(`Copying ${srcDir}/${file} to ${destSchemaDir}`);
+                fs.copyFileSync(path.join(srcDir, file), path.join(destSchemaDir, file));
+            });
+        };
+        const copySchemaFilesToDotSeed = () => {
+            const dest = path.join(dotSeedDir$1, SCHEMA_TS);
+            fs.copyFileSync(schemaFilePath, dest);
+            const sdkSrc = path.join(sdkRootDir, 'shared', 'sdkSchema');
+            copyFiles(sdkSrc, 'sdk');
+            const seedSchemaDir = path.join(sdkRootDir, 'browser', 'db', 'seedSchema');
+            copyFiles(seedSchemaDir, 'seed');
+        };
+        const runCommand = (command) => __awaiter(void 0, void 0, void 0, function* () {
+            const { stdout, stderr } = yield exec(command);
+            if (stderr) {
+                console.error(stderr);
+                return;
+            }
+            console.log(stdout);
+        });
+        const addModelsFromConfig = () => __awaiter(void 0, void 0, void 0, function* () {
+            // Developer created file with model definitions
+            const { models } = yield getConfig(schemaFilePath);
+            // console.log('[Seed Protocol] models:', models)
+            const db = getSdkDb();
+            yield addModelsToInternalDb(db, models);
+            console.log('[Seed Protocol] Added models to internal database');
+        });
+        const addSeedModels = () => __awaiter(void 0, void 0, void 0, function* () {
+            // const seedSchemaConfigPath = path.join(configDir, SEED_SCHEMA_CONFIG)
+            // const { models: SeedModels } = await getConfig(seedSchemaConfigPath)
+            //
+            // const db = getSdkDb()
+            //
+            // console.log(
+            //   '[Seed Protocol] Adding Seed models to internal database',
+            //   SeedModels,
+            // )
+            //
+            // await addModelsToInternalDb(db, SeedModels)
+            //
+            // console.log('[Seed Protocol] Added Seed models to internal database')
+        });
+        const updateSchema = (pathToConfig, pathToMeta) => __awaiter(void 0, void 0, void 0, function* () {
+            if (!fs.existsSync(pathToMeta)) {
+                yield runCommand(`${drizzleKitCommand} generate --config=${pathToConfig}`);
+            }
+            yield runCommand(`${drizzleKitCommand} migrate --config=${pathToConfig}`);
+        });
+        const runCommands = () => __awaiter(void 0, void 0, void 0, function* () {
+            // Here we setup the internal db that stores the developer's schema
+            yield updateSchema(sdkDbConfigPath, sdkDbMetaDir);
+            // This is SeedDb which is managed by the SDK but exports to the user's browser
+            yield updateSchema(seedDbConfigPath, seedDbMeta);
+            // Now we're building the schema defined by the developer
+            yield addModelsFromConfig();
+            // Here we generate the Drizzle schema files for the developer's models
+            yield syncDbWithDrizzleSchemaFile(schemaFilePath);
+            // Now we create the database made from the developer's schema
+            yield updateSchema(appDbConfigPath, browserAppDbMeta);
+            // Add Seed and Version models after any codegen has been done. Their
+            // code has already been added to the templates
+            yield addSeedModels();
+        });
+        ensureDirectories();
+        copySchemaFilesToDotSeed();
+        runCommands()
+            .then(() => {
+            if (!appFilesDirPath) {
+                console.log('[Seed Protocol] Finished running init script');
+            }
+            else {
+                return copyDotSeedFilesToAppFiles(appFilesDirPath, schemaFilePath);
+            }
+        })
+            .then(() => {
+            console.log('[Seed Protocol] Finished running init script');
+        });
+    }
+};
+const calledFrom = pathToFileURL(process$1.argv[1]).href;
+if (calledFrom.endsWith('node_modules/.bin/seed') ||
+    import.meta.url.endsWith('@seedprotocol/sdk/node/bin.js') ||
+    import.meta.url.endsWith('scripts/bin.ts')) {
+    // module was not imported but called directly
+    init(a);
+}
+
+export { init };
+//# sourceMappingURL=bin.js.map