@livestore/cli 0.4.0-dev.22 → 0.4.0-dev.24

package/src/module-loader.ts

@@ -4,6 +4,7 @@
  */
 import path from 'node:path'
 import { pathToFileURL } from 'node:url'
+
 import type { SyncBackend } from '@livestore/common'
 import { UnknownError } from '@livestore/common'
 import { isLiveStoreSchema, type LiveStoreSchema } from '@livestore/common/schema'
@@ -31,11 +32,11 @@ export const loadModuleConfig = ({
   configPath: string
 }): Effect.Effect<ModuleConfig, UnknownError, FileSystem.FileSystem> =>
   Effect.gen(function* () {
-    const abs = path.isAbsolute(configPath) ? configPath : path.resolve(process.cwd(), configPath)
+    const abs = path.isAbsolute(configPath) === true ? configPath : path.resolve(process.cwd(), configPath)
 
     const fs = yield* FileSystem.FileSystem
     const exists = yield* fs.exists(abs).pipe(UnknownError.mapToUnknownError)
-    if (!exists) {
+    if (exists === false) {
       return yield* UnknownError.make({
         cause: `Store module not found at ${abs}`,
         note: 'Make sure the path points to a valid LiveStore module',
@@ -51,15 +52,15 @@ export const loadModuleConfig = ({
         }),
     })
 
-    const schema = (mod as any)?.schema
-    if (!isLiveStoreSchema(schema)) {
+    const schema = (mod)?.schema
+    if (isLiveStoreSchema(schema) === false) {
       return yield* UnknownError.make({
         cause: `Module at ${abs} must export a valid LiveStore 'schema'`,
         note: `Ex: export { schema } from './src/livestore/schema.ts'`,
       })
     }
 
-    const syncBackendConstructor = (mod as any)?.syncBackend
+    const syncBackendConstructor = (mod)?.syncBackend
     if (typeof syncBackendConstructor !== 'function') {
       return yield* UnknownError.make({
         cause: `Module at ${abs} must export a 'syncBackend' constructor`,
@@ -67,17 +68,17 @@ export const loadModuleConfig = ({
       })
     }
 
-    const syncPayloadSchemaExport = (mod as any)?.syncPayloadSchema
+    const syncPayloadSchemaExport = (mod)?.syncPayloadSchema
     const syncPayloadSchema =
       syncPayloadSchemaExport === undefined
         ? Schema.JsonValue
-        : Schema.isSchema(syncPayloadSchemaExport)
+        : Schema.isSchema(syncPayloadSchemaExport) === true
           ? (syncPayloadSchemaExport as Schema.Schema<any>)
           : shouldNeverHappen(
               `Exported 'syncPayloadSchema' from ${abs} must be an Effect Schema (received ${typeof syncPayloadSchemaExport}).`,
             )
 
-    const syncPayloadExport = (mod as any)?.syncPayload
+    const syncPayloadExport = (mod)?.syncPayload
     const syncPayload = yield* (
       syncPayloadExport === undefined
         ? Effect.succeed<unknown>(undefined)

package/src/package-manager.ts

@@ -20,10 +20,10 @@ export type DetectPackageManagerResult = { _tag: 'supported'; pm: PackageManager
 export const detectPackageManager = (
   userAgent = process.env.npm_config_user_agent ?? '',
 ): DetectPackageManagerResult => {
-  if (userAgent.startsWith('bun/')) return { _tag: 'supported', pm: 'bun' }
-  if (userAgent.startsWith('pnpm/')) return { _tag: 'supported', pm: 'pnpm' }
-  if (userAgent.startsWith('npm/')) return { _tag: 'supported', pm: 'npm' }
-  if (userAgent.startsWith('yarn/')) return { _tag: 'unsupported', pm: 'yarn' }
+  if (userAgent.startsWith('bun/') === true) return { _tag: 'supported', pm: 'bun' }
+  if (userAgent.startsWith('pnpm/') === true) return { _tag: 'supported', pm: 'pnpm' }
+  if (userAgent.startsWith('npm/') === true) return { _tag: 'supported', pm: 'npm' }
+  if (userAgent.startsWith('yarn/') === true) return { _tag: 'unsupported', pm: 'yarn' }
 
   // Default to bun when the package manager can't be detected
   return { _tag: 'supported', pm: 'bun' }

package/src/sync-operations.ts

@@ -43,17 +43,17 @@ export const ExportFileSchema = Schema.Struct({
 
 export type ExportFile = typeof ExportFileSchema.Type
 
-export class ConnectionError extends Schema.TaggedError<ConnectionError>()('ConnectionError', {
+export class ConnectionError extends Schema.TaggedError<ConnectionError>('~@livestore/cli/ConnectionError')('ConnectionError', {
   cause: Schema.Defect,
   note: Schema.String,
 }) {}
 
-export class ExportError extends Schema.TaggedError<ExportError>()('ExportError', {
+export class ExportError extends Schema.TaggedError<ExportError>('~@livestore/cli/ExportError')('ExportError', {
   cause: Schema.Defect,
   note: Schema.String,
 }) {}
 
-export class ImportError extends Schema.TaggedError<ImportError>()('ImportError', {
+export class ImportError extends Schema.TaggedError<ImportError>('~@livestore/cli/ImportError')('ImportError', {
   cause: Schema.Defect,
   note: Schema.String,
 }) {}
@@ -81,7 +81,7 @@ export const makeSyncBackend = ({
   Effect.gen(function* () {
     const { syncBackendConstructor, syncPayload } = yield* loadModuleConfig({ configPath })
 
-    const syncBackend = yield* (syncBackendConstructor as SyncBackend.SyncBackendConstructor)({
+    const syncBackend = yield* syncBackendConstructor({
       storeId,
       clientId,
       /** syncPayload is validated against syncPayloadSchema by loadModuleConfig */
@@ -103,7 +103,7 @@ export const makeSyncBackend = ({
     yield* syncBackend.ping.pipe(
       Effect.timeout(CONNECTION_TIMEOUT_MS),
       Effect.catchAll((cause) => {
-        if (Cause.isTimeoutException(cause)) {
+        if (Cause.isTimeoutException(cause) === true) {
           return Effect.fail(
             new ConnectionError({
               cause,
@@ -123,8 +123,8 @@ export const makeSyncBackend = ({
     return syncBackend
   })
 
-const releaseSyncBackend = (syncBackend: SyncBackend.SyncBackend): Effect.Effect<void, never> => {
-  const maybeDisconnect = (syncBackend as { disconnect?: Effect.Effect<void, never> }).disconnect
+const releaseSyncBackend = (syncBackend: SyncBackend.SyncBackend): Effect.Effect<void> => {
+  const maybeDisconnect = (syncBackend as { disconnect?: Effect.Effect<void> }).disconnect
   const releaseEffect = maybeDisconnect ?? SubscriptionRef.set(syncBackend.isConnected, false)
   return releaseEffect.pipe(Effect.orElse(() => Effect.void))
 }
@@ -168,7 +168,7 @@ export const pullEventsFromSyncBackend = ({
             (cause) =>
               new ExportError({
                 cause,
-                note: `Failed to pull events from sync backend: ${cause}`,
+                note: `Failed to pull events from sync backend: ${String(cause)}`,
               }),
           ),
         )
@@ -228,8 +228,8 @@ export const validateExportData = ({
       Effect.mapError(
         (cause) =>
           new ImportError({
-            cause: new Error(`Invalid export file format: ${cause}`),
-            note: `Invalid export file format: ${cause}`,
+            cause: new Error(`Invalid export file format: ${String(cause)}`),
+            note: `Invalid export file format: ${String(cause)}`,
           }),
       ),
     )
@@ -262,7 +262,7 @@ export const pushEventsToSyncBackend = ({
   data: unknown
   force: boolean
   dryRun: boolean
-  onProgress?: (pushed: number, total: number) => Effect.Effect<void, never>
+  onProgress?: (pushed: number, total: number) => Effect.Effect<void>
 }): Effect.Effect<
   ImportResult,
   ImportError | UnknownError | ConnectionError,
@@ -276,20 +276,20 @@ export const pushEventsToSyncBackend = ({
           Effect.mapError(
             (cause) =>
               new ImportError({
-                cause: new Error(`Invalid export file format: ${cause}`),
-                note: `Invalid export file format: ${cause}`,
+                cause: new Error(`Invalid export file format: ${String(cause)}`),
+                note: `Invalid export file format: ${String(cause)}`,
               }),
           ),
         )
 
-        if (exportData.storeId !== storeId && !force) {
+        if (exportData.storeId !== storeId && force === false) {
           return yield* new ImportError({
             cause: new Error(`Store ID mismatch: file has '${exportData.storeId}', expected '${storeId}'`),
             note: `The export file was created for a different store. Use force option to import anyway.`,
           })
         }
 
-        if (dryRun) {
+        if (dryRun === true) {
           return {
             storeId,
             eventCount: exportData.events.length,
@@ -307,12 +307,12 @@ export const pushEventsToSyncBackend = ({
             (cause) =>
               new ImportError({
                 cause,
-                note: `Failed to check existing events: ${cause}`,
+                note: `Failed to check existing events: ${String(cause)}`,
               }),
           ),
         )
 
-        if (Option.isSome(existingBatchOption)) {
+        if (Option.isSome(existingBatchOption) === true) {
           const existingBatch = existingBatchOption.value
           const estimatedCount =
             existingBatch.pageInfo._tag === 'MoreKnown'
@@ -338,13 +338,13 @@ export const pushEventsToSyncBackend = ({
               (cause) =>
                 new ImportError({
                   cause,
-                  note: `Failed to push events at position ${i}: ${cause}`,
+                  note: `Failed to push events at position ${i}: ${String(cause)}`,
                 }),
             ),
           )
 
           pushed += batch.length
-          if (onProgress) {
+          if (onProgress !== undefined) {
             yield* onProgress(pushed, total)
           }
         }